• 多线程,了解-概念-实现方式-常见方法-安全问题-死锁-生产者消费者

    了解

    简单了解多线程

    是指从软件或者硬件上实现多个线程并发执行的技术。 具有多线程能力的计算机因有硬件支持而能够在同一时间执行多个线程，提升性能。

    简单了解多线程

                                                   

     简单了解多线程

                                                      

     简单了解多线程

                                                      

     简单了解多线程

                                                      

    概念

     线程相关的概念

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

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

    并发和并行

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

     

     并发和并行

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

      并发和并行

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

     

     并发和并行

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

     

    进程和线程

          进程：是正在运行的软件        

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

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

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

     进程和线程

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

                                                

                                               

                         

                         

                                              

                                               

      

    进程和线程

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

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

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

     小结

          并发和并行

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

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

           进程和线程

    进程：就是操作系统中正在运行的一个应用程序。

    线程：就是应用程序中做的事情。比如：360软件中的杀毒，扫描木马，清理垃圾。

    实现方式

    多线程的实现方式

    多线程的实现方案

    继承Thread类的方式进行实现

    实现Runnable接口的方式进行实现

    利用Callable和Future接口方式实现

    1. package com.itheima.threaddemo1;
    2.  
    3. public class MyThread extends Thread{
    4.     @Override
    5.     public void run() {
    6.         //代码就是线程在开启之后执行的代码
    7.         for (int i = 0; i < 100; i++) {
    8.             System.out.println("线程开启了" + i);
    9.         }
    10.     }
    11. }
    12.  
    13. package com.itheima.threaddemo1;
    14.  
    15. public class Demo {
    16.     public static void main(String[] args) {
    17.         //创建一个线程对象
    18.         MyThread t1 = new MyThread();
    19.         //创建一个线程对象
    20.         MyThread t2 = new MyThread();
    21.  
    22.         //t1.run();//表示的仅仅是创建对象,用对象去调用方法,并没有开启线程.
    23.         //t2.run();
    24.         //开启一条线程
    25.         t1.start();
    26.         //开启第二条线程
    27.         t2.start();
    28.     }
    29. }
    1. 线程开启了90
    2. 线程开启了99
    3. 线程开启了91
    4. 线程开启了92
    5. 线程开启了93
    6. 线程开启了94
    7. 线程开启了95
    8. 线程开启了96
    9. 线程开启了97
    10. 线程开启了98
    11. 线程开启了99
    12.  
    13. Process finished with exit code 0

     

    方案1：继承Thread类

    定义一个类MyThread继承Thread类

    在MyThread类中重写run()方法

    创建MyThread类的对象

    启动线程(如上)

    两个小问题：

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

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

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

             run()：封装线程执行的代码，直接调用，相当于普通方法的调用，并没有开启线程。          start()：启动线程；然后由JVM调用此线程的run()方法

    多线程的实现方式

    方式2：实现Runnable接口

    定义一个类MyRunnable实现Runnable接口

    在MyRunnable类中重写run()方法

    创建MyRunnable类的对象

    创建Thread类的对象，把MyRunnable对象作为构造方法的参数 启动线程

    1. package com.itheima.threaddemo2;
    2.  
    3. public class MyRunnable implements Runnable{
    4.     @Override
    5.     public void run() {
    6.         //线程启动后执行的代码
    7.         for (int i = 0; i < 100; i++) {
    8.             System.out.println(Thread.currentThread().getName() + "第二种方式实现多线程" + i);
    9.         }
    10.     }
    11. }

     测试类:

    1. package com.itheima.threaddemo2;
    2.  
    3. public class Demo {
    4.     public static void main(String[] args) {
    5.         //创建了一个参数的对象
    6.         MyRunnable mr = new MyRunnable();
    7.         //创建了一个线程对象,并把参数传递给这个线程.
    8.         //在线程启动之后,执行的就是参数里面的run方法
    9.         Thread t1 = new Thread(mr);
    10.         //开启线程
    11.         t1.start();
    12.  
    13.  
    14.         MyRunnable mr2 = new MyRunnable();
    15.         Thread t2 = new Thread(mr2);
    16.         t2.start();
    17.  
    18.     }
    19. }
    1. Thread-0第二种方式实现多线程96
    2. Thread-1第二种方式实现多线程96
    3. Thread-0第二种方式实现多线程97
    4. Thread-1第二种方式实现多线程97
    5. Thread-0第二种方式实现多线程98
    6. Thread-1第二种方式实现多线程98
    7. Thread-0第二种方式实现多线程99
    8. Thread-1第二种方式实现多线程99
    9.  
    10. Process finished with exit code 0

    方式3：Callable和Future

    定义一个类MyCallable实现Callable接口

    在MyCallable类中重写call()方法 创建MyCallable类的对象

    创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数

    创建Thread类的对象，把FutureTask对象作为构造方法的参数

    启动线程

    再调用get方法，就可以获取线程结束之后的结果。

    1. package com.itheima.threaddemo3;
    2.  
    3. import java.util.concurrent.Callable;
    4.  
    5. public class MyCallable implements Callable {
    6.     @Override
    7.     public String call() throws Exception {
    8.         for (int i = 0; i < 100; i++) {
    9.             System.out.println("跟女孩表白" + i);
    10.         }
    11.         //返回值就表示线程运行完毕之后的结果
    12.         return "答应";
    13.     }
    14. }

     测试类:

    1. package com.itheima.threaddemo3;
    2.  
    3. import java.util.concurrent.ExecutionException;
    4. import java.util.concurrent.FutureTask;
    5.  
    6. public class Demo {
    7.     public static void main(String[] args) throws ExecutionException, InterruptedException {
    8.         //线程开启之后需要执行里面的call方法
    9.         MyCallable mc = new MyCallable();
    10.  
    11.         //Thread t1 = new Thread(mc);
    12.  
    13.         //可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象
    14.         FutureTask ft = new FutureTask<>(mc);
    15.  
    16.         //创建线程对象
    17.         Thread t1 = new Thread(ft);
    18.  
    19.         String s = ft.get();
    20.         //开启线程
    21.         t1.start();
    22.  
    23.         //String s = ft.get();
    24.         System.out.println(s);
    25.     }
    26. }

     正确的代码:

    1.   public static void main(String[] args) throws ExecutionException, InterruptedException {
    2.  
    3.         //String s = ft.get();
    4.         //开启线程
    5.         t1.start();
    6.  
    7.         String s = ft.get();
    8.         System.out.println(s);
    9.     }

     三种方式的对比

    优点

    缺点

    实现Runnable、

    Callable接口

    扩展性强，实现该接口的同时还可以继承其他的类。

    编程相对复杂，不能直接使用Thread类中的方法

    继承Thread类

    编程比较简单，可以直接使用Thread类中的方法

    可以扩展性较差，

    不能再继承其他的类

    常见方法

    线程类的常见方法

    获取和设置线程名称

    获取线程的名字

    • String getName​()：返回此线程的名称

    Thread类中设置线程的名字

    • void setName​(String name)：将此线程的名称更改为等于参数 name
    • 通过构造方法也可以设置线程名称
    1. package com.itheima.threaddemo4;
    2.  
    3. public class MyThread extends Thread {
    4.  
    5.     public MyThread() {
    6.     }
    7.  
    8.     public MyThread(String name) {
    9.         super(name);
    10.     }
    11.  
    12.     @Override
    13.     public void run() {
    14.         for (int i = 0; i < 100; i++) {
    15.             System.out.println(getName() + "@@@" + i);
    16.         }
    17.     }
    18. }

     测试类:

    1. package com.itheima.threaddemo4;
    2.  
    3. public class Demo {
    4.     //1,线程是有默认名字的,格式:Thread-编号
    5.     public static void main(String[] args) {
    6.         MyThread t1 = new MyThread("小蔡");
    7.         MyThread t2 = new MyThread("小强");
    8.  
    9.         //t1.setName("小蔡");
    10.         //t2.setName("小强");
    11.  
    12.         t1.start();
    13.         t2.start();
    14.     }
    15. }
    1. 小强@@@97
    2. 小蔡@@@98
    3. 小强@@@98
    4. 小蔡@@@99
    5. 小强@@@99
    6.  
    7. Process finished with exit code 0

    获得当前线程的对象

    • public static Thread currentThread()：返回对当前正在执行的线程对象的引用
    1. package com.itheima.threaddemo5;
    2.  
    3. public class Demo {
    4.     public static void main(String[] args) {
    5.         String name = Thread.currentThread().getName();
    6.         System.out.println(name);
    7.     }
    8. }

    线程休眠

    • public static void sleep(long time)：让线程休眠指定的时间，单位为毫秒。
    1. package com.itheima.threaddemo6;
    2.  
    3. public class MyRunnable implements Runnable {
    4.     @Override
    5.     public void run() {
    6.         for (int i = 0; i < 100; i++) {
    7.             try {
    8.                 Thread.sleep(100);
    9.             } catch (InterruptedException e) {
    10.                 e.printStackTrace();
    11.             }
    12.  
    13.             System.out.println(Thread.currentThread().getName() + "---" + i);
    14.         }
    15.     }
    16. }

    测试类:(获取线程,休眠,获取名称)

    1. package com.itheima.threaddemo6;
    2.  
    3. public class Demo {
    4.     public static void main(String[] args) throws InterruptedException {
    5.         /*System.out.println("睡觉前");
    6.         Thread.sleep(3000);
    7.         System.out.println("睡醒了");*/
    8.  
    9.         MyRunnable mr = new MyRunnable();
    10.  
    11.         Thread t1 = new Thread(mr);
    12.         Thread t2 = new Thread(mr);
    13.  
    14.         t1.start();
    15.         t2.start();
    16.     }
    17. }
    1. Thread-0---97
    2. Thread-1---98
    3. Thread-0---98
    4. Thread-0---99
    5. Thread-1---99
    6.  
    7. Process finished with exit code 0

    线程调度

    多线程的并发运行：    

    计算机中的CPU，在任意时刻只能执行一条机器指令。每个线程只有获得CPU的使用权才能执行代码。      

     各个线程轮流获得CPU的使用权，分别执行各自的任务。

    线程有两种调度模型

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

            获取的 CPU 时间片相对多一些

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

                                    CPU

     线程的优先级

            public final void setPriority(int newPriority)    设置线程的优先级

            public final int getPriority()                              获取线程的优先级

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

     后台线程/守护线程

    public final void setDaemon(boolean on)：设置为守护线程

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

    为什么多线程会发生线程安全问题?

     多线程安全问题：就是存在多条线程操作同一条数据，而CPU执行时先将主内存中的数据拷贝一份做缓存，之后的操作不在请求主内存中拿数据而是从缓存中获取数据，如果执行完后有更改再同步回主内存，而导致了最终结果的错误，而单线程情况下则完全不会出现这一情况

     线程生命周期

    安全问题

    线程的安全问题

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

    思路：

    ①定义一个类Ticket实现Runnable接口，里面定义一个成员变量：private int ticketCount = 100;

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

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

          B：票数要减1

          C：卖光之后，线程停止

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

        A：创建Ticket类的对象

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

        C：启动线程

    1. package com.itheima.threaddemo9;
    2.  
    3. public class Ticket implements Runnable {
    4.     //票的数量
    5.     private int ticket = 100;
    6.     private Object obj = new Object();
    7.  
    8.     @Override
    9.     public void run() {
    10.         while(true){
    11.             synchronized (obj){//多个线程必须使用同一把锁.
    12.                 if(ticket <= 0){
    13.                     //卖完了
    14.                     break;
    15.                 }else{
    16.                     try {
    17.                         Thread.sleep(100);
    18.                     } catch (InterruptedException e) {
    19.                         e.printStackTrace();
    20.                     }
    21.                     ticket--;
    22.                     System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
    23.                 }
    24.             }
    25.         }
    26.     }
    27. }
    1. package com.itheima.threaddemo9;
    2.  
    3. public class Demo {
    4.     public static void main(String[] args) {
    5.         /*Ticket ticket1 = new Ticket();
    6.         Ticket ticket2 = new Ticket();
    7.         Ticket ticket3 = new Ticket();
    9.         Thread t1 = new Thread(ticket1);
    10.         Thread t2 = new Thread(ticket2);
    11.         Thread t3 = new Thread(ticket3);*/
    12.  
    13.         Ticket ticket = new Ticket();
    14.  
    15.         Thread t1 = new Thread(ticket);
    16.         Thread t2 = new Thread(ticket);
    17.         Thread t3 = new Thread(ticket);
    18.  
    19.         t1.setName("窗口一");
    20.         t2.setName("窗口二");
    21.         t3.setName("窗口三");
    22.  
    23.         t1.start();
    24.         t2.start();
    25.         t3.start();
    26.     }
    27. }

     改造:

    1.     @Override
    2.     public void run() {
    3.         while (true) {
    4.             // 当前这个this表示的是Ticket的票对象,我们在测试类中创建了几个票对象?
    5.             // 答: 1个,所以能保证多个线程使用的是同一个锁对象
    6.             synchronized (this){
    7.                 if (ticket <= 0) {
    8.                     //卖完了
    9.                     break;
    10.                 } else {
    11.                     System.out.println(Thread.currentThread().getName() + "正在卖" + ticket + "号票");
    12.                     ticket--;
    13.                 }
    14.             }
    15.         }
    16.     }

    卖票案例的思考

    刚才讲解了电影院卖票程序，好像没有什么问题。但是在实际生活中，售票时出票也是需要时间的， 所以，在出售一张票的时候，需要一点时间的延迟，接下来我们去修改卖票程序中卖票的动作： 每次出票时间100毫秒，用sleep()方法实现

    卖票出现了问题

            相同的票出现了多次

            出现了负数的票

    问题原因： 

    线程执行的随机性导致的

    卖票案例数据安全问题的解决

    卖票案例数据安全问题的解决

    为什么出现问题?(这也是我们判断多线程程序是否会有数据安全问题的标准)

            多线程操作共享数据

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

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

    怎么实现呢?

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

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

                                                                                

                                                                      

     

    同步代码块

    锁多条语句操作共享数据，可以使用[同步代码块]实现 

    格式：        

    synchronized(任意对象) {              

      多条语句操作共享数据的代码

     } 

    使用 Runnable就可以了

     默认情况是打开的，只要有一个线程进去执行代码了，锁就会关闭  

     当线程执行完出来了，锁才会自动打开

    同步的好处和弊端 

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

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

    同步方法 

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

    格式：

           修饰符 synchronized 返回值类型 方法名(方法参数) {    }

    同步代码块和同步方法的区别:

    同步代码块可以锁住指定代码,同步方法是锁住方法中所有代码

    同步代码块可以指定锁对象,同步方法不能指定锁对象 

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

    this 

    1. package com.itheima.threaddemo011;
    2. /*
    3.     任务类,将来只会创建一个任务类对象,可以由多个线程,共同执行这个任务对象
    4.  */
    5. public class MyRunnable implements Runnable {
    6.     private static int ticketCount = 100;
    7.  
    8.     @Override
    9.     public void run() {
    10.         // 希望通过这个run方法,获知当前是哪个线程正在执行任务,从而决定以什么方式保证数据安全;
    11.         while(true){
    12.             if("窗口一".equals(Thread.currentThread().getName())){
    13.                 //同步方法
    14.                 boolean result = synchronizedMthod();
    15.                 if(result){
    16.                     break;
    17.                 }
    18.             }
    19.  
    20.             if("窗口二".equals(Thread.currentThread().getName())){
    21.                 //同步代码块
    22.                 synchronized (MyRunnable.class){
    23.                     if(ticketCount == 0){
    24.                        break;
    25.                     }else{
    26.                         try {
    27.                             Thread.sleep(10);
    28.                         } catch (InterruptedException e) {
    29.                             e.printStackTrace();
    30.                         }
    31.                         ticketCount--;
    32.                         System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
    33.                     }
    34.                 }
    35.             }
    36.  
    37.         }
    38.     }
    39.  
    40.     private static synchronized boolean synchronizedMthod() {
    41.         if(ticketCount == 0){
    42.             return true;
    43.         }else{
    44.             try {
    45.                 Thread.sleep(10);
    46.             } catch (InterruptedException e) {
    47.                 e.printStackTrace();
    48.             }
    49.             ticketCount--;
    50.             System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
    51.             return false;
    52.         }
    53.     }
    54. }

    同步方法

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

    格式：

      修饰符 static synchronized 返回值类型 方法名(方法参数) {    }

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

    类名.class

    1. package com.itheima.day013_Teacher.demo02_MaiPiao;
    2. /*
    3.     这个类当成任务类
    4.  */
    5. public class Piao implements Runnable {
    6.  
    7.     // 票的总数
    8.      private  int p=100;
    9.     @Override
    10.     public void run() {
    11.        while (true){
    12.            synchronized (this){
    13.                if(p>0){
    14.                    // 卖票的行为
    15.                    System.out.println(Thread.currentThread().getName()+"卖了:"+p-- +"号票");
    16.                }else {
    17.                    System.out.println(Thread.currentThread().getName()+"卖票结束...");
    18.                    break;
    19.                }
    20.            }
    21.        }
    22.     }
    23.     /*@Override
    24.     public void run() {
    25.         while (true){
    26.             // 人为规定,返回true表示可以继续卖票,返回false,表示票卖完了
    27.            boolean r =  maiPiao();
    28.            if(!r){
    29.                break;
    30.            }
    31.         }
    32.     }*/
    33.  
    34.     private synchronized boolean maiPiao() {
    35.         if(p>0){
    36.             // 卖票的行为
    37.             System.out.println(Thread.currentThread().getName()+"卖了:"+p-- +"号票------------");
    38.             return true;
    39.         }else {
    40.             System.out.println(Thread.currentThread().getName()+"卖票结束...");
    41.             return false;
    42.         }
    43.     }
    44. }

    Lock锁

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

    Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作

    Lock中提供了获得锁和释放锁的方法

     void lock()：获得锁

    void unlock()：释放锁

     Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化

    ReentrantLock的构造方法

    ReentrantLock​()：创建一个ReentrantLock的实例

    1. package com.itheima.threaddemo012;
    2.  
    3. import java.util.concurrent.locks.ReentrantLock;
    4.  
    5. public class Ticket implements Runnable {
    6.     //票的数量
    7.     private int ticket = 100;
    8.     private Object obj = new Object();
    9.     private ReentrantLock lock = new ReentrantLock();
    10.  
    11.     @Override
    12.     public void run() {
    13.         while (true) {
    14.             //synchronized (obj){//多个线程必须使用同一把锁.
    15.             try {
    16.                 lock.lock();//获得锁
    17.                 if (ticket <= 0) {
    18.                     //卖完了
    19.                     break;
    20.                 } else {
    21.                     Thread.sleep(100);
    22.                     ticket--;
    23.                     System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
    24.                 }
    25.             } catch (InterruptedException e) {
    26.                 e.printStackTrace();
    27.             } finally {
    28.                 lock.unlock();//释放锁
    29.             }
    30.             // }
    31.         }
    32.     }
    33. }

    死锁

    死锁

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

     

     

     

     生产者消费者

    生产者消费者模式概述

    生产者消费者理想情况 

     

    生产者等待 

    1. package com.itheima.day013_Teacher.demo04_tongXin;
    2. /*
    3.     桌子类,会包含我们的共享数据
    4.  */
    5. public class ZhuoZi {
    6.     private String bz;// 包子是否存在
    7.     private int count;// 表示已经吃了多少个包子
    8.  
    9.     // 生成包子的方法
    10.     public void shengChan(){
    11.         synchronized (this){
    12.             if(count==9){
    13.                 System.out.println("生产够了...");
    14.                 Thread.currentThread().stop();
    15.             }
    16.             if(bz!=null){
    17.                 // 有包子,等待
    18.                 try {
    19.                     this.wait();// 将来被别的线程叫醒之后,代码会从这里继续往下走!
    20.                 } catch (InterruptedException e) {
    21.                     e.printStackTrace();
    22.                 }
    23.             }
    24.             // 做包子
    25.             bz = "猪肉馅的包子";
    26.             System.out.println("厨师做了一个:"+bz);
    27.             this.notifyAll();// 叫醒对方
    28.  
    29.         }
    30.     }
    31.  
    32.     // 吃包子的方法
    33.     public void chiBaoZi(){
    34.         synchronized (this){
    35.             if(count>=10){
    36.                 System.out.println("吃饱了...");
    37.                 Thread.currentThread().stop();
    38.                 ///System.exit(0);
    39.             }
    40.             if(bz ==null){
    41.                 // 说明没有包子,等一会
    42.                 try {
    43.                     this.wait();
    44.                 } catch (InterruptedException e) {
    45.                     e.printStackTrace();
    46.                 }
    47.             }
    48.             // 代码走到这里的时候,说明一定是有包子,开吃
    49.             count++;
    50.             System.out.println("吃货吃了:"+bz+",当前是第"+count+"个包子");
    51.             bz=null;
    52.             this.notifyAll();
    53.  
    54.         }
    55.     }
    56. }
    1. package com.itheima.day013_Teacher.demo04_tongXin;
    2.  
    3. public class ChiHuo implements Runnable{
    4.     // 通过构造方法传递想要使用的数据
    5.     public ChiHuo(ZhuoZi z) {
    6.         this.z = z;
    7.     }
    8.     private ZhuoZi z ;
    1. package com.itheima.day013_Teacher.demo04_tongXin;
    2.  
    3. public class ChuShi implements Runnable{
    4.     private ZhuoZi z;
    5.  
    6.     public ChuShi(ZhuoZi z) {
    7.         this.z = z;
    8.     }
    9.  
    10.     @Override
    11.     public void run() {
    12.         while (true){
    13.             z.shengChan();
    14.         }
    15.     }
    16. }
    1. package com.itheima.day013_Teacher.demo04_tongXin;
    2.  
    3. public class Entry {
    4.     public static void main(String[] args) {
    5.         ZhuoZi z = new ZhuoZi();
    6.         ChiHuo ch = new ChiHuo(z);
    7.         ChuShi cs = new ChuShi(z);
    8.         //创建线程,给厨师和吃货绑定任务
    9.         new Thread(ch).start();
    10.         new Thread(cs).start();
    11.  
    12.     }
    13. }
    1. 厨师做了一个:猪肉馅的包子
    2. 吃货吃了:猪肉馅的包子,当前是第1个包子
    3. 厨师做了一个:猪肉馅的包子
    4. 吃货吃了:猪肉馅的包子,当前是第2个包子
    5. 厨师做了一个:猪肉馅的包子
    6. 吃货吃了:猪肉馅的包子,当前是第3个包子
    7. 厨师做了一个:猪肉馅的包子
    8. 吃货吃了:猪肉馅的包子,当前是第4个包子
    9. 厨师做了一个:猪肉馅的包子
    10. 吃货吃了:猪肉馅的包子,当前是第5个包子
    11. 厨师做了一个:猪肉馅的包子
    12. 吃货吃了:猪肉馅的包子,当前是第6个包子
    13. 厨师做了一个:猪肉馅的包子
    14. 吃

     等待和唤醒的方法

    为了体现生产和消费过程中的等待和唤醒，Java就提供了几个方法供我们使用，这几个方法在Object类中 Object类的等待和唤醒方法：

    方法名

    说明

    void wait​()

    导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法

    void notify​()

    唤醒正在等待对象监视器的单个线程

    void notifyAll​()

    唤醒正在等待对象监视器的所有线程 

     阻塞队列实现等待唤醒机制

    阻塞队列继承结构

     

     阻塞队列实现等待唤醒机制

    BlockingQueue的核心方法：     

                    put(anObject):将参数放入队列，如果放不进去会阻塞。     
                    take():取出第一个数据，取不到会阻塞。

    常见BlockingQueue：     

              ArrayBlockingQueue：底层是数组，有界。     

              LinkedBlockingQueue：底层是链表，无界。但不是真正的无界，最大为int的最大值。

     

  • 相关阅读:
    springboot整合mybatis & druid
    手写redux的connect方法, 使用了subscribe获取最新数据
    手把手实例教你短视频定位,人设和变现方式,学会节省半年摸索时间
    Springboot改成Https请求【实战】
    Apache Doris1.0版本集群搭建、负载均衡与参数调优
    实时通信：长轮询与短轮询的对比
    [软件工具]ARW文件批量转图片jpg工具使用教程
    C++中的一些困惑（长期更新中）
    IEEE Transactions on Industrial Electronics工业电子TIE修改稿注意事项及提交须知
    Vue3: 获取元素DOM的方法
  • 原文地址：https://blog.csdn.net/weixin_46589095/article/details/128106157