• 传统生产者和消费者问题，Sychronized版和Lock版

    1.生产者和消费者问题Synchronized版

    面试：单例模式、排序算法、生产者消费者、死锁

    1. package com.kuang.pc;
    2.  
    3. /**
    4.  * 线程之间的通信问题，生产者和消费者问题！ 等待唤醒 ，通知唤醒
    5.  * 线程交替执行 A B 操作同一个变量 num=0
    6.  * A num+1;
    7.  * B num-1;
    8.  */
    9. public class A {
    10.  
    11.     public static void main(String[] args) {
    12.         Data data = new Data();
    13.         new Thread(()->{
    14.             for (int i = 0; i < 10; i++) {
    15.                 try {
    16.                     data.increment();
    17.                 } catch (InterruptedException e) {
    18.                     e.printStackTrace();
    19.                 }
    20.             }
    21.         },"A").start();
    22.         new Thread(()->{
    23.             for (int i = 0; i < 10; i++) {
    24.                 try {
    25.                     data.decrement();
    26.                 } catch (InterruptedException e) {
    27.                     e.printStackTrace();
    28.                 }
    29.             }
    30.         },"B").start();
    31.  
    32.     }
    33.  
    34. }
    35. // 判断等待，业务，通知
    36. class Data{//数字  资源类
    37.     private  int num = 0;
    38.  
    39.     //+1
    40.     public synchronized void increment() throws InterruptedException {
    41.        if(num!=0){
    42.            //等待
    43.            this.wait();
    44.        }
    45.        num++;
    46.        //通知其他线程，我+1完毕了
    47.         System.out.println(Thread.currentThread().getName()+"=>"+num);
    48.         this.notifyAll();
    49.     }
    50.  
    51.     //+1
    52.     public synchronized void decrement() throws InterruptedException {
    53.         if(num==0){
    54.             //等待
    55.             this.wait();
    56.         }
    57.         num--;
    58.         //通知其他线程，我-1完毕了
    59.         System.out.println(Thread.currentThread().getName()+"=>"+num);
    60.         this.notifyAll();
    61.     }
    62.  
    63. }

    问题A B C D 开四个线程跑，在if判断之后被唤醒，没判断条件被执行了两次增加，导致的虚假唤醒问题。 

    1. package com.kuang.pc;
    2.  
    3. /**
    4.  * 线程之间的通信问题，生产者和消费者问题！ 等待唤醒 ，通知唤醒
    5.  * 线程交替执行 A B 操作同一个变量 num=0
    6.  * A num+1;
    7.  * B num-1;
    8.  */
    9. public class A {
    10.  
    11.     public static void main(String[] args) {
    12.         Data data = new Data();
    13.         new Thread(()->{
    14.             for (int i = 0; i < 10; i++) {
    15.                 try {
    16.                     data.increment();
    17.                 } catch (InterruptedException e) {
    18.                     e.printStackTrace();
    19.                 }
    20.             }
    21.         },"A").start();
    22.         new Thread(()->{
    23.             for (int i = 0; i < 10; i++) {
    24.                 try {
    25.                     data.decrement();
    26.                 } catch (InterruptedException e) {
    27.                     e.printStackTrace();
    28.                 }
    29.             }
    30.         },"B").start();
    31.  
    32.  
    33.         new Thread(()->{
    34.             for (int i = 0; i < 10; i++) {
    35.                 try {
    36.                     data.increment();
    37.                 } catch (InterruptedException e) {
    38.                     e.printStackTrace();
    39.                 }
    40.             }
    41.         },"C").start();
    42.  
    43.         new Thread(()->{
    44.             for (int i = 0; i < 10; i++) {
    45.                 try {
    46.                     data.decrement();
    47.                 } catch (InterruptedException e) {
    48.                     e.printStackTrace();
    49.                 }
    50.             }
    51.         },"D").start();
    52.     }
    53.  
    54. }
    55. // 判断等待，业务，通知
    56. class Data{//数字  资源类
    57.     private  int num = 0;
    58.  
    59.     //+1
    60.     public synchronized void increment() throws InterruptedException {
    61.        while (num!=0){
    62.            //等待
    63.            this.wait();
    64.        }
    65.        num++;
    66.        //通知其他线程，我+1完毕了
    67.         System.out.println(Thread.currentThread().getName()+"=>"+num);
    68.         this.notifyAll();
    69.     }
    70.  
    71.     //+1
    72.     public synchronized void decrement() throws InterruptedException {
    73.        while (num==0){
    74.             //等待
    75.             this.wait();
    76.         }
    77.         num--;
    78.         //通知其他线程，我-1完毕了
    79.         System.out.println(Thread.currentThread().getName()+"=>"+num);
    80.         this.notifyAll();
    81.     }
    82.  
    83. }

     

    2.新版Lock锁解决消费者生产者问题。 

     

    1. package com.kuang.pc;
    2.  
    3. import java.util.concurrent.locks.Condition;
    4. import java.util.concurrent.locks.Lock;
    5. import java.util.concurrent.locks.ReentrantLock;
    6.  
    7. /**
    8.  * 线程之间的通信问题，生产者和消费者问题！ 等待唤醒 ，通知唤醒
    9.  * 线程交替执行 A B 操作同一个变量 num=0
    10.  * A num+1;
    11.  * B num-1;
    12.  */
    13. public class B {
    14.  
    15.     public static void main(String[] args) {
    16.         Data1 data = new Data1();
    17.         new Thread(()->{
    18.             for (int i = 0; i < 10; i++) {
    19.                 try {
    20.                     data.increment();
    21.                 } catch (InterruptedException e) {
    22.                     e.printStackTrace();
    23.                 }
    24.             }
    25.         },"A").start();
    26.         new Thread(()->{
    27.             for (int i = 0; i < 10; i++) {
    28.                 try {
    29.                     data.decrement();
    30.                 } catch (InterruptedException e) {
    31.                     e.printStackTrace();
    32.                 }
    33.             }
    34.         },"B").start();
    35.  
    36.  
    37.         new Thread(()->{
    38.             for (int i = 0; i < 10; i++) {
    39.                 try {
    40.                     data.increment();
    41.                 } catch (InterruptedException e) {
    42.                     e.printStackTrace();
    43.                 }
    44.             }
    45.         },"C").start();
    46.  
    47.         new Thread(()->{
    48.             for (int i = 0; i < 10; i++) {
    49.                 try {
    50.                     data.decrement();
    51.                 } catch (InterruptedException e) {
    52.                     e.printStackTrace();
    53.                 }
    54.             }
    55.         },"D").start();
    56.     }
    57.  
    58.     }
    59.  
    60.     
    61. // 判断等待，业务，通知
    62. class Data1 {//数字  资源类
    63.     private int num = 0;
    64.  
    65.     Lock lock=new ReentrantLock();
    66.     Condition condition = lock.newCondition();
    67. //        condition.await();等待
    68. //        condition.signalAll();唤醒全部
    69.     //+1
    70.     public void increment() throws InterruptedException {
    71.         lock.lock();
    72.         try {
    73.           //业务代码
    74.             while (num != 0) {
    75.                 //等待
    76.                 condition.await();
    77.             }
    78.             num++;
    79.             System.out.println(Thread.currentThread().getName() + "=>" + num);
    80.             //通知其他线程，我+1完毕了
    81.             condition.signalAll();
    82.         } catch (Exception e) {
    83.             e.printStackTrace();
    84.         } finally {
    85.             lock.unlock();
    86.         }
    87.  
    88.  
    89.     }
    90.  
    91.     //+1
    92.     public void decrement() throws InterruptedException {
    93.         lock.lock();
    94.         try {
    95.             //业务代码
    96.             while (num == 0) {
    97.                 //等待
    98.                 condition.await();
    99.             }
    100.             num--;
    101.             System.out.println(Thread.currentThread().getName() + "=>" + num);
    102.             //通知其他线程，我-1完毕了
    103.             condition.signalAll();
    104.         } catch (Exception e) {
    105.             e.printStackTrace();
    106.         } finally {
    107.             lock.unlock();
    108.         }
    109.  
    110.  
    111.     }
    112.  
    113. }

    任何一个新的技术，绝对不是仅仅只覆盖了原来的技术，优势，和补充！

    Condition 优势精准通知，唤醒线程

    1. package com.kuang.pc;
    2.  
    3. import java.util.concurrent.locks.Condition;
    4. import java.util.concurrent.locks.Lock;
    5. import java.util.concurrent.locks.ReentrantLock;
    6.  
    7. /**
    8.  * 线程之间的通信问题，生产者和消费者问题！ 等待唤醒 ，通知唤醒
    9.  * 线程交替执行 A B 操作同一个变量 num=0
    10.  * A num+1;
    11.  * B num-1;
    12.  */
    13. public class C {
    14.  
    15.     public static void main(String[] args) {
    16.         Data2 data = new Data2();
    17.  
    18.         new Thread(()->{
    19.             for (int i = 0; i < 10; i++) {
    20.                 data.printA();
    21.             }
    22.         },"A").start();
    23.         new Thread(()->{
    24.             for (int i = 0; i < 10; i++) {
    25.                 data.printB();
    26.             }
    27.         },"B").start();
    28.         new Thread(()->{
    29.             for (int i = 0; i < 10; i++) {
    30.                 data.printC();
    31.             }
    32.         },"C").start();
    33.  
    34.  
    35.     }
    36.  
    37. }
    38. // 判断等待，业务，通知
    39. class Data2 {//数字  资源类
    40.  
    41.  
    42.     private Lock lock=new ReentrantLock();
    43.     private Condition condition1 = lock.newCondition();
    44.     private Condition condition2 = lock.newCondition();
    45.     private Condition condition3 = lock.newCondition();
    46.  
    47.     private int num=1;
    48.     public void printA(){
    49.         lock.lock();
    50.         try {
    51.             if (num!=1){
    52.                 //等待
    53.                 condition1.await();
    54.             }
    55.             num=2;
    56.             System.out.println(Thread.currentThread().getName()+":Aaa");
    57.          //唤醒，唤醒指定的人，B
    58.            condition2.signal();
    59.         } catch (Exception e) {
    60.             e.printStackTrace();
    61.         } finally {
    62.             lock.unlock();
    63.         }
    64.  
    65.  
    66.     }
    67.     public void printB(){
    68.         lock.lock();
    69.         try {
    70.             if (num!=2){
    71.                 condition2.await();
    72.             }
    73.             num=3;
    74.             System.out.println(Thread.currentThread().getName()+":Bbb");
    75.             condition3.signal();
    76.         } catch (Exception e) {
    77.             e.printStackTrace();
    78.         } finally {
    79.             lock.unlock();
    80.         }
    81.  
    82.     }
    83.     public void printC(){
    84.         lock.lock();
    85.         try {
    86.             if (num!=3){
    87.                 condition3.await();
    88.             }
    89.             System.out.println(Thread.currentThread().getName()+":Ccc");
    90.             num=1;
    91.             condition1.signal();
    92.         } catch (Exception e) {
    93.             e.printStackTrace();
    94.         } finally {
    95.             lock.unlock();
    96.         }
    97.  
    98.     }
    99.  
    100. }
    101.  
    102.

    精准唤醒线程  Condition

  • 相关阅读:
    【JVM学习笔记】JVM内存区域定义与内存结构
    Midjourney 商用实战升级版 AI给模特换脸
    矩阵键盘中断扫描
    Betaflight关于STM32F405 SBUS协议兼容硬件电气特性问题
    10 个简单有用的 Python 编程技巧
    k8s nginx .yaml 测试
    C语言之内存函数篇（3）
    pytorch 初始化
    CocosCreator 面试题（五）TS有什么优缺点？为什么要用TS？
    树，二叉树的概念与结构
  • 原文地址：https://blog.csdn.net/qq_53374893/article/details/132916231