实现多线程

简单了解多线程【理解】

是指从软件或者硬件上实现多个线程并发执行的技术。

具有多线程能力的计算机因有硬件支持而能够在同一时间执行多个线程，提升性能。

并发和并行【理解】

  • 并行：在同一时刻，有多个指令在多个CPU上同时执行。

  • 并发：在同一时刻，有多个指令在单个CPU上交替执行。

进程和线程【理解】

  • 进程：是正在运行的程序

    独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位

    动态性：进程的实质是程序的一次执行过程，进程是动态产生，动态消亡的

    并发性：任何进程都可以同其他进程一起并发执行

  • 线程：是进程中的单个顺序控制流，是一条执行路径，是一个进程中的执行场景/执行单元。

    ​ 单线程：一个进程如果只有一条执行路径，则称为单线程程序

    ​ 多线程：一个进程如果有多条执行路径，则称为多线程程序

实现多线程方式一：继承Thread类【应用】

  • 方法介绍

    方法名 说明
    void run() 在线程开启后，此方法将被调用执行
    void start() 使此线程开始执行，Java虚拟机会调用run方法()

  • 实现步骤

    • 定义一个类MyThread继承Thread类
    • 在MyThread类中重写run()方法
    • 创建MyThread类的对象
    • 启动线程

  • 代码演示

    1. public class MyThread extends Thread {
    2.     @Override
    3.     public void run() {
    4.         for(int i=0; i<100; i++) {
    5.             System.out.println(i);
    6.         }
    7.     }
    8. }
    9. public class MyThreadDemo {
    10.     public static void main(String[] args) {
    11.         MyThread my1 = new MyThread();
    12.         MyThread my2 = new MyThread();
    14. //        my1.run();
    15. //        my2.run();
    17.         //void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法
    18.         my1.start();
    19.         my2.start();
    20.     }
    21. }

  • 两个小问题

    • 为什么要重写run()方法？

      因为run()是用来封装被线程执行的代码

    • run()方法和start()方法的区别？

      run()：封装线程执行的代码，直接调用，相当于普通方法的调用，并没有开启线程

      start()：启动线程；然后由JVM调用此线程的run()方法

实现多线程方式二：实现Runnable接口【应用】

  • Thread构造方法

    方法名 说明
    Thread(Runnable target) 分配一个新的Thread对象
    Thread(Runnable target, String name) 分配一个新的Thread对象

  • 实现步骤

    • 定义一个类MyRunnable实现Runnable接口
    • 在MyRunnable类中重写run()方法
    • 创建MyRunnable类的对象
    • 创建Thread类的对象，把MyRunnable对象作为构造方法的参数
    • 启动线程

  • 代码演示

    1. public class MyRunnable implements Runnable {
    2.     @Override
    3.     public void run() {
    4.         for(int i=0; i<100; i++) {
    5.             System.out.println(Thread.currentThread().getName()+":"+i);
    6.         }
    7.     }
    8. }
    9. public class MyRunnableDemo {
    10.     public static void main(String[] args) {
    11.         //创建MyRunnable类的对象
    12.         MyRunnable my = new MyRunnable();
    14.         //创建Thread类的对象，把MyRunnable对象作为构造方法的参数
    15.         //Thread(Runnable target)
    16. //        Thread t1 = new Thread(my);
    17. //        Thread t2 = new Thread(my);
    18.         //Thread(Runnable target, String name)
    19.         Thread t1 = new Thread(my,"坦克");
    20.         Thread t2 = new Thread(my,"飞机");
    22.         //启动线程
    23.         t1.start();
    24.         t2.start();
    25.     }
    26. }

实现多线程方式三: 实现Callable接口【应用】

  • 方法介绍

    方法名 说明
    V call() 计算结果，如果无法计算结果，则抛出一个异常
    FutureTask(Callable callable) 创建一个 FutureTask，一旦运行就执行给定的 Callable
    V get() 如有必要，等待计算完成，然后获取其结果

  • 理解：FutureTask 想一个中间类，可以利用它实现接口，创建Thread线程，也可以利用它获取线程返回值

  • 实现步骤

    • 定义一个类MyCallable实现Callable接口
    • 在MyCallable类中重写call()方法
    • 创建MyCallable类的对象
    • 创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数
    • 创建Thread类的对象，把FutureTask对象作为构造方法的参数
    • 启动线程
    • 再调用get方法，就可以获取线程结束之后的结果。

  • 代码演示

    1. public class MyCallable implements Callable<String> {
    2.     @Override
    3.     public String call() throws Exception {
    4.         for (int i = 0; i < 100; i++) {
    5.             System.out.println("跟女孩表白" + i);
    6.         }
    7.         //返回值就表示线程运行完毕之后的结果
    8.         return "答应";
    9.     }
    10. }
    11. public class Demo {
    12.     public static void main(String[] args) throws ExecutionException, InterruptedException {
    13.         //线程开启之后需要执行里面的call方法
    14.         MyCallable mc = new MyCallable();
    16.         //Thread t1 = new Thread(mc);
    18.         //可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象
    19.         FutureTask<String> ft = new FutureTask<>(mc);
    21.         //创建线程对象
    22.         Thread t1 = new Thread(ft);
    24.         String s = ft.get();
    25.         //开启线程
    26.         t1.start();
    28.         //String s = ft.get();
    29.         System.out.println(s);
    30.     }
    31. }

  • 三种实现方式的对比

    • 实现Runnable、Callable接口

      • 好处: 扩展性强，实现该接口的同时还可以继承其他的类
      • 缺点: 编程相对复杂，不能直接使用Thread类中的方法
    • 继承Thread类
      • 好处: 编程比较简单，可以直接使用Thread类中的方法
      • 缺点: 可以扩展性较差，不能再继承其他的类

设置和获取线程名称【应用】

  • 方法介绍

    方法名 说明
    void setName(String name) 将此线程的名称更改为等于参数name
    String getName() 返回此线程的名称
    Thread currentThread() 返回对当前正在执行的线程对象的引用

  • 代码演示

    1. public class MyThread extends Thread {
    2.     public MyThread() {}
    3.     public MyThread(String name) {
    4.         super(name);
    5.     }
    7.     @Override
    8.     public void run() {
    9.         for (int i = 0; i < 100; i++) {
    10.             System.out.println(getName()+":"+i);
    11.         }
    12.     }
    13. }
    14. public class MyThreadDemo {
    15.     public static void main(String[] args) {
    16.         MyThread my1 = new MyThread();
    17.         MyThread my2 = new MyThread();
    18.         //线程有默认名字，格式：thread-编号
    19.         //void setName(String name)：将此线程的名称更改为等于参数 name
    20.         my1.setName("高铁");
    21.         my2.setName("飞机");
    23.         //Thread(String name)
    24.         MyThread my1 = new MyThread("高铁");
    25.         MyThread my2 = new MyThread("飞机");
    26.         //构造方法也可以给线程设置名字，但是要写出线程的无参和有参构造函数
    27.         /*class MyThread extends Thread{
    28.           public MyThread(String name) {
    29.              super(name);
    30.           }
    31.           public MyThread() {
    32.             @Override
    33.             public void run(){
    34.              //执行的代码
    35.             }
    36.         }
    37.   	  */
    38.         my1.start();
    39.         my2.start();
    41.         //static Thread currentThread() 返回对当前正在执行的线程对象的引用
    42.         System.out.println(Thread.currentThread().getName());//MyThread类内没有getName（）方法
    43.     }
    44. }

线程休眠【应用】

  • 相关方法

    方法名 说明
    static void sleep(long millis) 使当前正在执行的线程停留（暂停执行）指定的毫秒数

  • 代码演示

    1. public class MyRunnable implements Runnable {
    2.     @Override
    3.     public void run() {
    4.         for (int i = 0; i < 100; i++) {
    5.             try {
    6.                 Thread.sleep(100);
    7.             } catch (InterruptedException e) {
    8.                 e.printStackTrace();
    9.             }
    11.             System.out.println(Thread.currentThread().getName() + "---" + i);
    12.         }
    13.     }
    14. }
    15. public class Demo {
    16.     public static void main(String[] args) throws InterruptedException {
    17.         /*System.out.println("睡觉前");
    18.         Thread.sleep(3000);
    19.         System.out.println("睡醒了");*/
    21.         MyRunnable mr = new MyRunnable();
    23.         Thread t1 = new Thread(mr);
    24.         Thread t2 = new Thread(mr);
    26.         t1.start();
    27.         t2.start();
    28.     }
    29. }

线程优先级【应用】

  • 线程调度

    • 两种调度方式

      • 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
      • 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些

    • Java使用的是抢占式调度模型

    • 随机性

      假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的

  • 优先级相关方法

    方法名 说明
    final int getPriority() 返回此线程的优先级
    final void setPriority(int newPriority) 更改此线程的优先级线程默认优先级是5；线程优先级的范围是：1-10

  • 注意

    线程优先级的范围是1~10

    线程默认优先级是5

    优先级只是提高线程抢占CPU执行权的几率，并不一定提高实际的抢占率

  • 代码演示

    1. public class MyCallable implements Callable<String> {
    2.     @Override
    3.     public String call() throws Exception {
    4.         for (int i = 0; i < 100; i++) {
    5.             System.out.println(Thread.currentThread().getName() + "---" + i);
    6.         }
    7.         return "线程执行完毕了";
    8.     }
    9. }
    10. public class Demo {
    11.     public static void main(String[] args) {
    12.         //优先级: 1 - 10 默认值:5
    13.         MyCallable mc = new MyCallable();
    15.         FutureTask<String> ft = new FutureTask<>(mc);
    17.         Thread t1 = new Thread(ft);
    18.         t1.setName("飞机");
    19.         t1.setPriority(10);
    20.         //System.out.println(t1.getPriority());//5
    21.         t1.start();
    23.         MyCallable mc2 = new MyCallable();
    25.         FutureTask<String> ft2 = new FutureTask<>(mc2);
    27.         Thread t2 = new Thread(ft2);
    28.         t2.setName("坦克");
    29.         t2.setPriority(1);
    30.         //System.out.println(t2.getPriority());//5
    31.         t2.start();
    32.     }
    33. }

守护线程【应用】

  • 相关方法

    方法名 说明
    void setDaemon(boolean on) 将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出

  • 代码演示

    1. public class MyThread1 extends Thread {
    2.     @Override
    3.     public void run() {
    4.         for (int i = 0; i < 10; i++) {
    5.             System.out.println(getName() + "---" + i);
    6.         }
    7.     }
    8. }
    9. public class MyThread2 extends Thread {
    10.     @Override
    11.     public void run() {
    12.         for (int i = 0; i < 100; i++) {
    13.             System.out.println(getName() + "---" + i);
    14.         }
    15.     }
    16. }
    17. public class Demo {
    18.     public static void main(String[] args) {
    19.         MyThread1 t1 = new MyThread1();
    20.         MyThread2 t2 = new MyThread2();
    22.         t1.setName("女神");
    23.         t2.setName("备胎");
    25.         //把第二个线程设置为守护线程
    26.         //当普通线程执行完之后,那么守护线程也没有继续运行下去的必要了.
    27.         t2.setDaemon(true);
    29.         t1.start();
    30.         t2.start();
    31.     }
    32. }

线程同步

卖票【应用】

  • 案例需求

    某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票

  • 实现步骤

    • 定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;

    • 在SellTicket类中重写run()方法实现卖票，代码步骤如下

    • 判断票数大于0，就卖票，并告知是哪个窗口卖的

    • 卖了票之后，总票数要减1

    • 票卖没了，线程停止

    • 定义一个测试类SellTicketDemo，里面有main方法，代码步骤如下

    • 创建SellTicket类的对象

    • 创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称

    • 启动线程

  • 代码实现

    1. public class SellTicket implements Runnable {
    2.     private int tickets = 100;
    3.     //在SellTicket类中重写run()方法实现卖票，代码步骤如下
    4.     @Override
    5.     public void run() {
    6.         while (true) {
    7.             if(ticket <= 0){
    8.                     //卖完了
    9.                     break;
    10.                 }else{
    11.                     try {
    12.                         Thread.sleep(100);
    13.                     } catch (InterruptedException e) {
    14.                         e.printStackTrace();
    15.                     }
    16.                     ticket--;
    17.                     System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
    18.                 }
    19.         }
    20.     }
    21. }
    22. public class SellTicketDemo {
    23.     public static void main(String[] args) {
    24.         //创建SellTicket类的对象
    25.         SellTicket st = new SellTicket();
    27.         //创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
    28.         Thread t1 = new Thread(st,"窗口1");
    29.         Thread t2 = new Thread(st,"窗口2");
    30.         Thread t3 = new Thread(st,"窗口3");
    32.         //启动线程
    33.         t1.start();
    34.         t2.start();
    35.         t3.start();
    36.     }
    37. }

卖票案例的问题【理解】

  • 卖票出现了问题

    • 相同的票出现了多次

    • 出现了负数的票

  • 问题产生原因

    线程执行的随机性导致的,可能在卖票过程中丢失cpu的执行权,导致出现问题

同步代码块解决数据安全问题【应用】

  • 安全问题出现的条件

    • 是多线程环境

    • 有共享数据

    • 有多条语句操作共享数据

  • 如何解决多线程安全问题呢?

    • 基本思想：让程序没有安全问题的环境

  • 怎么实现呢?

    • 把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可

    • Java提供了同步代码块的方式来解决

  • 同步代码块格式：

    1. synchronized(任意对象) {
    2. 	多条语句操作共享数据的代码
    3. }

  • 注意同步代码块锁住的对象必须是多个线程共享的对象，否则无效。

    synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁

    1. public class test33 {
    2.   public static void main(String[] args) {
    3.       MyThread thread1 = new MyThread();
    4.       MyThread thread2 = new MyThread();
    5.       MyThread thread3 = new MyThread();
    6.       thread1.setName("线程1");
    7.       thread2.setName("线程2");
    8.       thread3.setName("线程3");
    9.       thread1.start();
    10.       thread2.start();
    11.       thread3.start();
    12.   }
    13. }
    15. class MyThread extends Thread {
    16.   private static int ticket = 100;
    17.   public  Object obj = new Object();
    19.   @Override
    20.   public void run() {
    22.       while (true) {
    23.           synchronized (obj) {
    24.               if (ticket <= 0) break;
    25.               else {
    26.                   try {
    27.                       Thread.sleep(10);
    28.                   } catch (InterruptedException e) {
    29.                       e.printStackTrace();
    30.                   }
    31.                   ticket--;
    32.                   System.out.println(Thread.currentThread().getName() + "执行了，还剩下" + ticket + "张票");
    34.               }
    35.           }
    36.       }
    38.   }
    39. }

    该案例中创建的三个线程，有三个不同的Object成员对象，不共享，相当于没加锁，无效。

    需要改成 public static Object obj = new Object(); 让obj成为共享的成员对象。

    同样，该案例中如果锁为this及synchronized(this)则依然无效，因为this所指的对象不是共享的。

  • 同步的好处和弊端

    • 好处：解决了多线程的数据安全问题

    • 弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

  • 代码演示

    1. public class SellTicket implements Runnable {
    2.     private int tickets = 100;
    3.     private Object obj = new Object();
    5.     @Override
    6.     public void run() {
    7.         while (true) {
    8.             synchronized (obj) { // 对可能有安全问题的代码加锁,多个线程必须使用同一把锁
    9.                 //t1进来后，就会把这段代码给锁起来
    10.                 if (tickets > 0) {
    11.                     try {
    12.                         Thread.sleep(100);
    13.                         //t1休息100毫秒
    14.                     } catch (InterruptedException e) {
    15.                         e.printStackTrace();
    16.                     }
    17.                     //窗口1正在出售第100张票
    18.                     System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
    19.                     tickets--; //tickets = 99;
    20.                 }
    21.             }
    22.             //t1出来了，这段代码的锁就被释放了
    23.         }
    24.     }
    25. }
    27. public class SellTicketDemo {
    28.     public static void main(String[] args) {
    29.         SellTicket st = new SellTicket();
    31.         Thread t1 = new Thread(st, "窗口1");
    32.         Thread t2 = new Thread(st, "窗口2");
    33.         Thread t3 = new Thread(st, "窗口3");
    35.         t1.start();
    36.         t2.start();
    37.         t3.start();
    38.     }
    39. }

同步方法解决数据安全问题【应用】

  • 同步方法的格式

    同步方法：就是把synchronized关键字加到方法上

    1. 修饰符 synchronized 返回值类型 方法名(方法参数) {
    2. 	方法体；
    3. }

    同步方法的锁对象是什么呢?

    ​ this

  • 静态同步方法

    同步静态方法：就是把synchronized关键字加到静态方法上

    1. 修饰符 static synchronized 返回值类型 方法名(方法参数) {
    2. 	方法体；
    3. }

    同步静态方法的锁对象是什么呢?

    ​ 类名.class

  • 代码演示

    1. public class MyRunnable implements Runnable {
    2.     private static int ticketCount = 100;
    4.     @Override
    5.     public void run() {
    6.         while(true){
    7.             if("窗口一".equals(Thread.currentThread().getName())){
    8.                 //同步方法
    9.                 boolean result = synchronizedMthod();
    10.                 if(result){
    11.                     break;
    12.                 }
    13.             }
    15.             if("窗口二".equals(Thread.currentThread().getName())){
    16.                 //同步代码块
    17.                 synchronized (MyRunnable.class){
    18.                     if(ticketCount == 0){
    19.                        break;
    20.                     }else{
    21.                         try {
    22.                             Thread.sleep(10);
    23.                         } catch (InterruptedException e) {
    24.                             e.printStackTrace();
    25.                         }
    26.                         ticketCount--;
    27.                         System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
    28.                     }
    29.                 }
    30.             }
    32.         }
    33.     }
    35.     private static synchronized boolean synchronizedMthod() {
    36.         if(ticketCount == 0){
    37.             return true;
    38.         }else{
    39.             try {
    40.                 Thread.sleep(10);
    41.             } catch (InterruptedException e) {
    42.                 e.printStackTrace();
    43.             }
    44.             ticketCount--;
    45.             System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
    46.             return false;
    47.         }
    48.     }
    49. }

    测试类

    1. public class Demo {
    2.     public static void main(String[] args) {
    3.         MyRunnable mr = new MyRunnable();
    5.         Thread t1 = new Thread(mr);
    6.         Thread t2 = new Thread(mr);
    8.         t1.setName("窗口一");
    9.         t2.setName("窗口二");
    11.         t1.start();
    12.         t2.start();
    13.     }
    15. }

Lock锁【应用】

虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock

Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化。默认锁住当前对象

  • ReentrantLock构造方法

    方法名 说明
    ReentrantLock() 创建一个ReentrantLock的实例

  • 加锁解锁方法

    方法名 说明
    void lock() 获得锁
    void unlock() 释放锁

  • 代码演示

    1. public class Ticket implements Runnable {
    2.     //票的数量
    3.     private int ticket = 100;
    4.     private Object obj = new Object();
    5.     private ReentrantLock lock = new ReentrantLock();
    7.     @Override
    8.     public void run() {
    9.         while (true) {
    10.             //synchronized (obj){//多个线程必须使用同一把锁.
    11.             try {
    12.                 lock.lock();
    13.                 if (ticket <= 0) {
    14.                     //卖完了
    15.                     break;
    16.                 } else {
    17.                     Thread.sleep(100);
    18.                     ticket--;
    19.                     System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
    20.                 }
    21.             } catch (InterruptedException e) {
    22.                 e.printStackTrace();
    23.             } finally {
    24.                 lock.unlock();
    25.             }
    26.             // }
    27.         }
    28.     }
    29. }
    31. public class Demo {
    32.     public static void main(String[] args) {
    33.         Ticket ticket = new Ticket();
    35.         Thread t1 = new Thread(ticket);
    36.         Thread t2 = new Thread(ticket);
    37.         Thread t3 = new Thread(ticket);
    39.         t1.setName("窗口一");
    40.         t2.setName("窗口二");
    41.         t3.setName("窗口三");
    43.         t1.start();
    44.         t2.start();
    45.         t3.start();
    46.     }
    47. }

死锁【理解】

  • 概述

    线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行

  • 什么情况下会产生死锁

    1. 资源有限
    2. 同步嵌套（锁的嵌套）

  • 代码演示

    1. public class Demo {
    2.     public static void main(String[] args) {
    3.         Object objA = new Object();
    4.         Object objB = new Object();
    6.         new Thread(()->{
    7.             while(true){
    8.                 synchronized (objA){
    9.                     //线程一
    10.   				  try {
    11.                             Thread.sleep(100); //休眠为了使线程二获得锁objB
    12.                         } catch (InterruptedException e) {
    13.                              e.printStackTrace();
    14.                           }
    15.                     synchronized (objB){
    16.                         System.out.println("小康同学正在走路");
    17.                     }
    18.                 }
    19.             }
    20.         }).start();
    22.         new Thread(()->{
    23.             while(true){
    24.                 synchronized (objB){
    25.                     //线程二
    26.   				  try {
    27.                             Thread.sleep(100); //休眠为了使线程一获得锁objA
    28.                         } catch (InterruptedException e) {
    29.                              e.printStackTrace();
    30.                           }
    31.                     synchronized (objA){
    32.                         System.out.println("小薇同学正在走路");
    33.                     }
    34.                 }
    35.             }
    36.         }).start();
    37.     }
    38. }

生产者消费者

生产者和消费者模式概述【应用】

  • 概述

    生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻。

    所谓生产者消费者问题，实际上主要是包含了两类线程：

    ​ 一类是生产者线程用于生产数据

    ​ 一类是消费者线程用于消费数据

    为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库

    生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为

    消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为

  • Object类的等待和唤醒方法

    方法名 说明
    void wait() 导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法
    void notify() 唤醒正在等待对象监视器的单个线程
    void notifyAll() 唤醒正在等待对象监视器的所有线程

生产者和消费者案例【应用】

  • 案例需求

    • 桌子类(Desk)：定义表示包子数量的变量,定义锁对象变量,定义标记桌子上有无包子的变量

    • 生产者类(Cooker)：实现Runnable接口，重写run()方法，设置线程任务

      1.判断是否有包子,决定当前线程是否执行

      2.如果有包子,就进入等待状态,如果没有包子,继续执行,生产包子

      3.生产包子之后,更新桌子上包子状态,唤醒消费者消费包子

    • 消费者类(Foodie)：实现Runnable接口，重写run()方法，设置线程任务

      1.判断是否有包子,决定当前线程是否执行

      2.如果没有包子,就进入等待状态,如果有包子,就消费包子

      3.消费包子后,更新桌子上包子状态,唤醒生产者生产包子

    • 测试类(Demo)：里面有main方法，main方法中的代码步骤如下

      创建生产者线程和消费者线程对象

      分别开启两个线程

  • 代码实现

    1. public class Desk {
    3.     //定义一个标记
    4.     //true 就表示桌子上有汉堡包的,此时允许吃货执行
    5.     //false 就表示桌子上没有汉堡包的,此时允许厨师执行
    6.     public static boolean flag = false;
    8.     //汉堡包的总数量
    9.     public static int count = 10;
    11.     //锁对象
    12.     public static final Object lock = new Object();
    13. }
    15. public class Cooker extends Thread {
    16. //    生产者步骤：
    17. //            1，判断桌子上是否有汉堡包
    18. //    如果有就等待，如果没有才生产。
    19. //            2，把汉堡包放在桌子上。
    20. //            3，叫醒等待的消费者开吃。
    21.     @Override
    22.     public void run() {
    23.         while(true){
    24.             synchronized (Desk.lock){
    25.                 if(Desk.count == 0){
    26.                     break;
    27.                 }else{
    28.                     if(!Desk.flag){
    29.                         //生产
    30.                         System.out.println("厨师正在生产汉堡包");
    31.                         Desk.flag = true;
    32.                         Desk.lock.notifyAll();
    33.                     }else{
    34.                         try {
    35.                             Desk.lock.wait();
    36.                         } catch (InterruptedException e) {
    37.                             e.printStackTrace();
    38.                         }
    39.                     }
    40.                 }
    41.             }
    42.         }
    43.     }
    44. }
    46. public class Foodie extends Thread {
    47.     @Override
    48.     public void run() {
    49. //        1，判断桌子上是否有汉堡包。
    50. //        2，如果没有就等待。
    51. //        3，如果有就开吃
    52. //        4，吃完之后，桌子上的汉堡包就没有了
    53. //                叫醒等待的生产者继续生产
    54. //        汉堡包的总数量减一
    56.         //套路:
    57.             //1. while(true)死循环
    58.             //2. synchronized 锁,锁对象要唯一
    59.             //3. 判断,共享数据是否结束. 结束
    60.             //4. 判断,共享数据是否结束. 没有结束
    61.         while(true){
    62.             synchronized (Desk.lock){
    63.                 if(Desk.count == 0){
    64.                     break;
    65.                 }else{
    66.                     if(Desk.flag){
    67.                         //有
    68.                         System.out.println("吃货在吃汉堡包");
    69.                         Desk.flag = false;
    70.                         Desk.lock.notifyAll();
    71.                         Desk.count--;
    72.                     }else{
    73.                         //没有就等待
    74.                         //使用什么对象当做锁,那么就必须用这个对象去调用等待和唤醒的方法.
    75.                         try {
    76.                             Desk.lock.wait();
    77.                         } catch (InterruptedException e) {
    78.                             e.printStackTrace();
    79.                         }
    80.                     }
    81.                 }
    82.             }
    83.         }
    85.     }
    86. }
    88. public class Demo {
    89.     public static void main(String[] args) {
    90.         /*消费者步骤：
    91.         1，判断桌子上是否有汉堡包。
    92.         2，如果没有就等待。
    93.         3，如果有就开吃
    94.         4，吃完之后，桌子上的汉堡包就没有了
    95.                 叫醒等待的生产者继续生产
    96.         汉堡包的总数量减一*/
    98.         /*生产者步骤：
    99.         1，判断桌子上是否有汉堡包
    100.         如果有就等待，如果没有才生产。
    101.         2，把汉堡包放在桌子上。
    102.         3，叫醒等待的消费者开吃。*/
    104.         Foodie f = new Foodie();
    105.         Cooker c = new Cooker();
    107.         f.start();
    108.         c.start();
    110.     }
    111. }

生产者和消费者案例优化【应用】

  • 需求

    • 将Desk类中的变量,采用面向对象的方式封装起来
    • 生产者和消费者类中构造方法接收Desk类对象,之后在run方法中进行使用
    • 创建生产者和消费者线程对象,构造方法中传入Desk类对象
    • 开启两个线程

  • 代码实现

    1. public class Desk {
    3.     //定义一个标记
    4.     //true 就表示桌子上有汉堡包的,此时允许吃货执行
    5.     //false 就表示桌子上没有汉堡包的,此时允许厨师执行
    6.     //public static boolean flag = false;
    7.     private boolean flag;
    9.     //汉堡包的总数量
    10.     //public static int count = 10;
    11.     //以后我们在使用这种必须有默认值的变量
    12.    // private int count = 10;
    13.     private int count;
    15.     //锁对象
    16.     //public static final Object lock = new Object();
    17.     private final Object lock = new Object();
    19.     public Desk() {
    20.         this(false,10); // 在空参内部调用带参,对成员变量进行赋值,之后就可以直接使用成员变量了
    21.     }
    23.     public Desk(boolean flag, int count) {
    24.         this.flag = flag;
    25.         this.count = count;
    26.     }
    28.     public boolean isFlag() {
    29.         return flag;
    30.     }
    32.     public void setFlag(boolean flag) {
    33.         this.flag = flag;
    34.     }
    36.     public int getCount() {
    37.         return count;
    38.     }
    40.     public void setCount(int count) {
    41.         this.count = count;
    42.     }
    44.     public Object getLock() {
    45.         return lock;
    46.     }
    48.     @Override
    49.     public String toString() {
    50.         return "Desk{" +
    51.                 "flag=" + flag +
    52.                 ", count=" + count +
    53.                 ", lock=" + lock +
    54.                 '}';
    55.     }
    56. }
    58. public class Cooker extends Thread {
    60.     private Desk desk;
    62.     public Cooker(Desk desk) {
    63.         this.desk = desk;
    64.     }
    65. //    生产者步骤：
    66. //            1，判断桌子上是否有汉堡包
    67. //    如果有就等待，如果没有才生产。
    68. //            2，把汉堡包放在桌子上。
    69. //            3，叫醒等待的消费者开吃。
    71.     @Override
    72.     public void run() {
    73.         while(true){
    74.             synchronized (desk.getLock()){
    75.                 if(desk.getCount() == 0){
    76.                     break;
    77.                 }else{
    78.                     //System.out.println("验证一下是否执行了");
    79.                     if(!desk.isFlag()){
    80.                         //生产
    81.                         System.out.println("厨师正在生产汉堡包");
    82.                         desk.setFlag(true);
    83.                         desk.getLock().notifyAll();
    84.                     }else{
    85.                         try {
    86.                             desk.getLock().wait();
    87.                         } catch (InterruptedException e) {
    88.                             e.printStackTrace();
    89.                         }
    90.                     }
    91.                 }
    92.             }
    93.         }
    94.     }
    95. }
    97. public class Foodie extends Thread {
    98.     private Desk desk;
    100.     public Foodie(Desk desk) {
    101.         this.desk = desk;
    102.     }
    104.     @Override
    105.     public void run() {
    106. //        1，判断桌子上是否有汉堡包。
    107. //        2，如果没有就等待。
    108. //        3，如果有就开吃
    109. //        4，吃完之后，桌子上的汉堡包就没有了
    110. //                叫醒等待的生产者继续生产
    111. //        汉堡包的总数量减一
    113.         //套路:
    114.             //1. while(true)死循环
    115.             //2. synchronized 锁,锁对象要唯一
    116.             //3. 判断,共享数据是否结束. 结束
    117.             //4. 判断,共享数据是否结束. 没有结束
    118.         while(true){
    119.             synchronized (desk.getLock()){
    120.                 if(desk.getCount() == 0){
    121.                     break;
    122.                 }else{
    123.                     //System.out.println("验证一下是否执行了");
    124.                     if(desk.isFlag()){
    125.                         //有
    126.                         System.out.println("吃货在吃汉堡包");
    127.                         desk.setFlag(false);
    128.                         desk.getLock().notifyAll();
    129.                         desk.setCount(desk.getCount() - 1);
    130.                     }else{
    131.                         //没有就等待
    132.                         //使用什么对象当做锁,那么就必须用这个对象去调用等待和唤醒的方法.
    133.                         try {
    134.                             desk.getLock().wait();
    135.                         } catch (InterruptedException e) {
    136.                             e.printStackTrace();
    137.                         }
    138.                     }
    139.                 }
    140.             }
    141.         }
    143.     }
    144. }
    146. public class Demo {
    147.     public static void main(String[] args) {
    148.         /*消费者步骤：
    149.         1，判断桌子上是否有汉堡包。
    150.         2，如果没有就等待。
    151.         3，如果有就开吃
    152.         4，吃完之后，桌子上的汉堡包就没有了
    153.                 叫醒等待的生产者继续生产
    154.         汉堡包的总数量减一*/
    156.         /*生产者步骤：
    157.         1，判断桌子上是否有汉堡包
    158.         如果有就等待，如果没有才生产。
    159.         2，把汉堡包放在桌子上。
    160.         3，叫醒等待的消费者开吃。*/
    162.         Desk desk = new Desk();
    164.         Foodie f = new Foodie(desk);
    165.         Cooker c = new Cooker(desk);
    167.         f.start();
    168.         c.start();
    170.     }
    171. }

阻塞队列基本使用【理解】

  • 阻塞队列继承结构

  • 常见BlockingQueue:

    ArrayBlockingQueue: 底层是数组,有界

    LinkedBlockingQueue: 底层是链表,无界.但不是真正的无界,最大为int的最大值

  • BlockingQueue的核心方法:

    put(anObject): 将参数放入队列,如果放不进去会阻塞

    take(): 取出第一个数据,取不到会阻塞

  • 代码示例

    1. public class Demo02 {
    2.     public static void main(String[] args) throws Exception {
    3.         // 创建阻塞队列的对象,容量为 1
    4.         ArrayBlockingQueue<String> arrayBlockingQueue = new ArrayBlockingQueue<>(1);
    6.         // 存储元素
    7.         arrayBlockingQueue.put("汉堡包");
    9.         // 取元素
    10.         System.out.println(arrayBlockingQueue.take());
    11.         System.out.println(arrayBlockingQueue.take()); // 取不到会阻塞
    13.         System.out.println("程序结束了");
    14.     }
    15. }

阻塞队列实现等待唤醒机制【理解】

  • 案例需求

    • 生产者类(Cooker)：实现Runnable接口，重写run()方法，设置线程任务

      1.构造方法中接收一个阻塞队列对象

      2.在run方法中循环向阻塞队列中添加包子

      3.打印添加结果

    • 消费者类(Foodie)：实现Runnable接口，重写run()方法，设置线程任务

      1.构造方法中接收一个阻塞队列对象

      2.在run方法中循环获取阻塞队列中的包子

      3.打印获取结果

    • 测试类(Demo)：里面有main方法，main方法中的代码步骤如下

      创建阻塞队列对象

      创建生产者线程和消费者线程对象,构造方法中传入阻塞队列对象

      分别开启两个线程

  • 代码实现

    1. public class Cooker extends Thread {
    3.     private ArrayBlockingQueue<String> bd;
    5.     public Cooker(ArrayBlockingQueue<String> bd) {
    6.         this.bd = bd;
    7.     }
    8. //    生产者步骤：
    9. //            1，判断桌子上是否有汉堡包
    10. //    如果有就等待，如果没有才生产。
    11. //            2，把汉堡包放在桌子上。
    12. //            3，叫醒等待的消费者开吃。
    14.     @Override
    15.     public void run() {
    16.         while (true) {
    17.             try {
    18.                 bd.put("汉堡包");
    19.                 System.out.println("厨师放入一个汉堡包");
    20.             } catch (InterruptedException e) {
    21.                 e.printStackTrace();
    22.             }
    23.         }
    24.     }
    25. }
    27. public class Foodie extends Thread {
    28.     private ArrayBlockingQueue<String> bd;
    30.     public Foodie(ArrayBlockingQueue<String> bd) {
    31.         this.bd = bd;
    32.     }
    34.     @Override
    35.     public void run() {
    36. //        1，判断桌子上是否有汉堡包。
    37. //        2，如果没有就等待。
    38. //        3，如果有就开吃
    39. //        4，吃完之后，桌子上的汉堡包就没有了
    40. //                叫醒等待的生产者继续生产
    41. //        汉堡包的总数量减一
    43.         //套路:
    44.         //1. while(true)死循环
    45.         //2. synchronized 锁,锁对象要唯一
    46.         //3. 判断,共享数据是否结束. 结束
    47.         //4. 判断,共享数据是否结束. 没有结束
    48.         while (true) {
    49.             try {
    50.                 String take = bd.take();
    51.                 System.out.println("吃货将" + take + "拿出来吃了");
    52.             } catch (InterruptedException e) {
    53.                 e.printStackTrace();
    54.             }
    55.         }
    57.     }
    58. }
    60. public class Demo {
    61.     public static void main(String[] args) {
    62.         ArrayBlockingQueue<String> bd = new ArrayBlockingQueue<>(1);
    64.         Foodie f = new Foodie(bd);
    65.         Cooker c = new Cooker(bd);
    67.         f.start();
    68.         c.start();
    69.     }
    70. }

注意：最终的打印结果可能回出现同样的语句重复输出，这不符合预期。

这是因为ArrayBlockingQueue的底层源代码是用ReentrantLock锁了，实现线程同步，但是System.out语句是我们自己写的，打印语句没有实现线程同步，所以可能打印的时候出现问题，这只是个小问题。

【重学Java】多线程基础（三种创建方式，线程安全，生产者消费者）的更多相关文章

  1. Java多线程的三种实现方式

    java多线程的三种实现方式 一.继承Thread类 二.实现Runnable接口 三.使用ExecutorService, Callable, Future 无论是通过继承Thread类还是实现Ru ...

  2. java 多线程编程三种实现方式

    一种是继承Thread类,一种是实现Runable接口,还有一种是实现callable接口: 有博主说只有前面2种方式,我个人愚见是三种,主要详细介绍下callable的使用: 三种线程的我的个人理解 ...

  3. Java多线程的几种创建方式

    方法一:继承Thread类,重写run方法,直接调用start方法开启线程. /** * 继承Thread类,直接调用start方法开启线程. * @author LuRenJia */ public ...

  4. java多线程的两种创建方式

    方式一:继承Thread类 1.创建一个继承于Thread类的子类 2.重写Thread类的run()方法---> 将此线程执行的操作声明在run()中 3.创建Thread类的子类的对象 4. ...

  5. 【Java 线程的深入研究1】Java 提供了三种创建线程的方法

    Java 提供了三种创建线程的方法: 通过实现 Runnable 接口: 通过继承 Thread 类本身: 通过 Callable 和 Future 创建线程. 1.通过实现 Runnable 接口来 ...

  6. JavaScript 闭包的详细分享（三种创建方式）（附小实例）

    JavaScript闭包的详细理解 一.原理:闭包函数--指有权访问私有函数里面的变量和对象还有方法等:通俗的讲就是突破私有函数的作用域,让函数外面能够使用函数里面的变量及方法. 1.第一种创建方式 ...

  7. java多线程的几种实现方式

    java多线程的几种实现方式 1.继承Thread类,重写run方法2.实现Runnable接口,重写run方法,实现Runnable接口的实现类的实例对象作为Thread构造函数的target3.通 ...

  8. ORM中choices参数(重要)、MTV于MVC模型、多对多关系三种创建方式

    choices参数(重要) **使用方式

  9. Struts2之命名空间与Action的三种创建方式

    看到上面的标题,相信大家已经知道我们接下来要探讨的知识了,一共两点:1.package命名空间设置:2.三种Action的创建方式.下面我们开始本篇的内容: 首先我们聊一聊命名空间的知识,namesp ...

  10. 2019年6月14日 Web框架之Django_07 进阶操作（MTV与MVC、多对多表三种创建方式、前后端传输数据编码格式contentType、ajax、自定义分页器）

    摘要 MTV与MVC 多对多表三种创建方式 ajax ,前后端传输数据编码格式contentType 批量插入数据和自定义分页器 一.MVC与MTV MVC(Model View Controller ...

随机推荐

  1. Django框架中logging的使用

    Django框架中logging的使用 日志是我们在项目开发中必不可少的一个环节,Python中内置的logging已经足够优秀到可以直接在项目中使用. 本文介绍了如何在DJango项目中配置日志. ...

  2. Docker学习(2) 安装

    1 在Ubanru中安装 简单安装: 2 windows安装docker 3 OS X 安装docker

  3. Go语言协程并发---原子操作

    package main import ( "fmt" "sync/atomic" ) /* 用原子来替换锁,其主要原因是: 原子操作由底层硬件支持,而锁则由操 ...

  4. Selenium click不生效 报错selenium.common.exceptions.InvalidArgumentException

    记录在使用selenium过程中踩的坑------ 在使用selenium时,用click点击网站弹出的文件上传框的"上传文件"按钮不生效,报错selenium.common.ex ...

  5. FCN与U-Net语义分割算法

    FCN与U-Net语义分割算法 图像语义分割(Semantic Segmentation)是图像处理和是机器视觉技术中关于图像理解的重要一环,也是 AI 领域中一个重要的分支.语义分割即是对图像中每一 ...

  6. 用于ONNX的TensorRT后端

    用于ONNX的TensorRT后端 解析ONNX模型以使用TensorRT执行. 另请参阅TensorRT文档. 有关最近更改的列表,请参见changelog. 支持的TensorRT版本 Maste ...

  7. CVPR2020：利用图像投票增强点云中的三维目标检测（ImVoteNet）

    CVPR2020:利用图像投票增强点云中的三维目标检测(ImVoteNet) ImVoteNet: Boosting 3D Object Detection in Point Clouds With ...

  8. CVPR2020：点云弱监督三维语义分割的多路径区域挖掘

    CVPR2020:点云弱监督三维语义分割的多路径区域挖掘 Multi-Path Region Mining for Weakly Supervised 3D Semantic Segmentation ...

  9. 那些年，我们一起做过的KNX智能化控制经典案例！

    那些年,我们一起做过的KNX经典案例! 光阴之箭已经穿越年轮,抵达2021 GVS在2008年加入KNX国际协会,成为中国首批引进KNX标准的企业,此后,还率先研发出基于KNX的核心协议栈,定标准,做 ...

  10. 惊呆了，Spring Boot居然这么耗内存！

    Spring Boot总体来说,搭建还是比较容易的,特别是Spring Cloud全家桶,简称亲民微服务,但在发展趋势中,容器化技术已经成熟,面对巨耗内存的Spring Boot,小公司表示用不起.如 ...