生产者与消费者问题（synchronized版和JUC版）

最新推荐文章于 2022-05-03 22:44:57 发布
最新推荐文章于 2022-05-03 22:44:57 发布
阅读量249 收藏
点赞数 2
分类专栏： 多线程 Java基础知识 面试题大汇总
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hello_cmy/article/details/105638868
版权

生产者和消费者问题synchronized版

package com.cc.pc;
/**
* 线程之间的通信问题：生产者和消费者问题！ 等待唤醒，通知唤醒
* 线程交替执行 A B 操作同一个变量 num = 0
* A num+1
* B num-1
*/
public class A {
    public static void main(String[] args) {
        Data data = new Data();

        new Thread(()->{
            for (int i = 0; i < 10 ; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 10 ; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
    }
}


//判断等待，业务，通知
class Data {
    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        if(number!=0) {  //0
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，我+1完毕了
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        if(number==0) { //1
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，我-1完毕了
        this.notifyAll();
    }
}

运行结果：

A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0

在这里插入图片描述
if 改为 while 判断

package com.cc.pc;
/**
 * 线程之间的通信问题：生产者和消费者问题！ 等待唤醒，通知唤醒
 * 线程交替执行 A B 操作同一个变量 num = 0
 * A num+1
 * B num-1
 */
public class A {
    public static void main(String[] args) {
        Data data = new Data();

        new Thread(()->{
            for (int i = 0; i < 10 ; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 10 ; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
    }
}


//判断等待，业务，通知
class Data {
    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        while(number!=0) {  //0
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，我+1完毕了
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        while(number==0) { //1
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，我-1完毕了
        this.notifyAll();
    }
}

JUC版的生产者和消费者
在这里插入图片描述

package com.cc.pc;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class B {
    public static void main(String[] args) {
        Data2 data = new Data2();

        new Thread(()->{
            for (int i = 0; i < 10 ; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 10 ; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 10 ; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();

        new Thread(()->{
            for (int i = 0; i < 10 ; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}


//判断等待，业务，通知
class Data2 {
    private int number = 0;

    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    //condition.await()   等待
    //condition.signalAll()  唤醒全部
    //+1
    public void increment() throws InterruptedException {
        lock.lock();
        try {
            while (number != 0) {  //0
                //等待
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            //通知其他线程，我+1完毕了
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //-1
    public void decrement() throws InterruptedException {
        lock.lock();
        try {
            while (number == 0) {  //1
                //等待
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            //通知其他线程，我+1完毕了
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

这个结果运行出来是随机的，没有顺序，我们想让他有序的去执行，那怎么办呢？

condition 精准的通知和唤醒线程

package com.cc.pc;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class C {
    public static void main(String[] args) {
        Data3 data = new Data3();

        new Thread(()->{
            for (int i = 0; i < 10 ; i++) {
               data.printA();
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 10 ; i++) {
                data.printB();
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 10 ; i++) {
                data.printC();
            }
        },"C").start();

    }
}


//判断等待，业务，通知
class Data3 {

    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();

    private int number = 1; //1A 2B 3C

    public void printA() {
        lock.lock();
        try {
            while (number != 1) {
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>AAAAAAAA");
            //唤醒,唤醒指定的人，B
            number = 2;
            condition2.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printB() {
        lock.lock();
        try {
            while (number != 2) {
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>BBBBBBBB");
            //唤醒,唤醒指定的人，C
            number = 3;
            condition3.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printC() {
        lock.lock();
        try {
            while (number != 3) {
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>CCCCCC");
            //唤醒,唤醒指定的人，A
            number = 1;
            condition1.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

//可看到是有序的执行
A=>AAAAAAAA
B=>BBBBBBBB
C=>CCCCCC
A=>AAAAAAAA
B=>BBBBBBBB
C=>CCCCCC
A=>AAAAAAAA
B=>BBBBBBBB
C=>CCCCCC
A=>AAAAAAAA
B=>BBBBBBBB
C=>CCCCCC
A=>AAAAAAAA
B=>BBBBBBBB
C=>CCCCCC
A=>AAAAAAAA
B=>BBBBBBBB
C=>CCCCCC
A=>AAAAAAAA
B=>BBBBBBBB
C=>CCCCCC
A=>AAAAAAAA
B=>BBBBBBBB
C=>CCCCCC
A=>AAAAAAAA
B=>BBBBBBBB
C=>CCCCCC
A=>AAAAAAAA
B=>BBBBBBBB
C=>CCCCCC
hello_cmy
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
juc详解juc详解juc详解juc详解juc详解juc详解juc详解
08-02
- `LinkedBlockingQueue`：有界的阻塞队列，适用于生产者-消费者模型。 4. **同步器**： - `CountDownLatch`：计数器，用于等待多个线程完成操作后再继续执行。 - `CyclicBarrier`：回环栅栏，允许一组线程等待...
狂神说JUC代码狂神说JUC代码
09-11
- **BlockingQueue**：阻塞队列，是一种特殊的线程安全的数据结构，当队列满时，生产者线程会被阻塞；当队列空时，消费者线程会被阻塞。 5. **原子类**：如AtomicInteger、AtomicLong等，它们提供了一种无锁的原子...
狂神JUC——Synchronized版的生产者和消费者问题
黄坤的博客
06-02 967
package com.company; /** * 消费者和生产者：线程之间的通信问题 * 等待唤醒，通知唤醒 * 不同的线程操作同一个变量 */ public class ProducerAndConsumer { public static void main(String[] args) { Data data = new Data(); //添加线程 new Thread(()->{ for (i
【多线程】生产者消费者问题（Synchronized和Lock版本实现）
历乱的日记簿
05-05 117
一、Synchronized和Lock 【追根溯源】Sychronized 是Java内置的关键字，而Lock是一个类 【自动挡与手动挡】Sychronized 自动释放锁，而Lock是手动释放（unlock）。（假如没有手动释放，就会造成死锁） 【锁的状态】Sychronized 不能获取锁的状态，Lock可以； 【在一棵树上吊死】Sychronized 当一个线程获取资源的锁，那么另外想要该资源的线程会一直等待，而Lock有tryLock，超时放弃等待； 【锁的量】Sychronized 适用于锁少量
JUC_生产者和消费者_synchronized_Lock_BlockingQueue
baihehaitangyijiu的博客
05-21 161
问题1：虚假唤醒 问题2：为什么用while(num != 0) {this.wait()},不能用if public class pc_demo_1 { public static void main(String[] args) { // 多线程操作共享资源 Data data = new Data(); new Thread(() -> { for (int i = 0; i < 10; i++) {
synchronized版-生产者和消费者模式
说完
05-25 192
生产者和消费者模式 三个对象、生产者、消费者、商品库存 商品库存是共享的 共享的数据要进行线程同步安全保护 默认商品的数量为0，程序执行 1、生产者生成10个商品然后停止生成。释放商品库存锁 （Object.wait()） 2、消费者依次消费10个商品然后停止消费、释放商品锁（Object.wait()）、唤醒生成者生成(Object.notifyAll()) 3、生产者生成10个商品然后停止生成。释放商品库存锁（Object.wait()）、唤醒消费者消费(Object.notifyAll())
JUC版的生产者和消费者问题
zhangqiang180的博客
03-30 163
synchronized 和lock 对比 代码实现： public class B { public static void main(String[] args) { Data2 data2 = new Data2(); new Thread(()->{ for(int i=0;i<10;i++){ ...
JUC多线程编程之生产者与消费者问题（Synchronized和JUC版）
不会编程的派大星的博客
04-21 129
生产者与消费者问题 在面试中，生产者与消费者是高频问题之一 1.生产者和消费者问题 Synchronized 版 public class A { public static void main(String[] args) { Data data = new Data(); new Thread(() -> { for (int i = 0; i < 10; i++) { try {
JUC编程02：生产者与消费者问题
WADE_AJJD的博客
07-28 128
一、Synchronized解决方案 代码演示 package com.haust.pc; /** * 线程之间的通信问题：生产者和消费者问题！ 等待唤醒，通知唤醒 * 线程交替执行 A B 操作同一个变量 num = 0 * A num+1 * B num-1 */ public class A { public static void main(String[] args) { Data data = new Data(); new Th
生产者和消费者问题 Synchronized 版本，防止虚假唤醒
qq_42732184的博客
05-03 303
package com.han.demo01; public class TestPC { public static void main(String[] args) { Data data = new Data(); new Thread(() -> { for (int i = 0; i < 20; i++) { try { data.increment
JUC（3）生产者与消费者问题（线程通信）
wang_luwei的博客
11-23 194
文章目录一、传统版本，用Synchronized实现的1.1存在的问题(虚假唤醒)，线程不只两个时二、juc版（lock锁）的生产者与消费者问题三、Condition 条件 有什么用呢？ 线程之间的通信问题：生产者与消费者问题 一、传统版本，用Synchronized实现的 package com.wlw.producerandconsumer; /** * 线程之间的通信问题：生产者与消费者问题 * 两个线程交替执行，操作同一变量，一开始为0，A B 一个执行+1 另一个执行-1 */ pu
Java——JUC
12-29
它们在多线程环境下提供线程安全的数据存储和访问，适用于生产者消费者模型，常用于线程间数据交换。 3. **并发集合（Concurrent Collections）** - `ConcurrentHashMap`：线程安全的哈希映射表，相比`...
JUC
03-19
- LinkedBlockingQueue：有界的阻塞队列，基于链表结构，适用于生产者消费者模型。 4. **原子类**： - AtomicInteger，AtomicLong，AtomicBoolean等：提供原子操作的整数、长整型和布尔类型变量，避免了显式同步...
个人学习-JUC-笔记
最新发布
02-25
- **BlockingQueue**：阻塞队列，常用于生产者-消费者模型，如ArrayBlockingQueue、LinkedBlockingQueue。 6. **原子类** - **Atomic包**：如AtomicInteger、AtomicLong等，提供原子操作，避免显式锁定。 7. **...
Java 8 stream().filter()过滤器的使用
热门推荐
hello_cmy的博客
08-17 1万+
需求 现在有这么一个需求，在一个list数组里面存了一些数据，我想要取出特定条件下的数据。比如我想取出学生的年龄在10岁以上的，再比如想取出张三这个人的一些信息。 思路解决 如果想要拿到一组list中的一些数据，就是对数据进行一些筛选，我们的原生方法就是遍历list数组，然后作判断，拿出相应条件的数据。这是一种很麻烦的方法，所以在Java 8 就出现了一种很简单的方法，过滤器。只需要很简单的一行，就可以拿到你想要的数据。 具体代码讲解 package com.cc; public class .
HashMap的三种遍历方式
hello_cmy的博客
03-09 1万+
集合在应用以及面试中都占有很重要的位置，今天就说说HashMap的遍历方式，偶然在一次面试中被问到的。 关于具体的实现，可以看源码。 import java.util.HashMap; import java.util.Iterator; import java.util.Map; public class Test { public static void main(String[] args) { HashMap<String, String> hashMap =
DocumentEvent事件
hello_cmy的博客
03-17 3886
1 DocumentEvent事件源 文本区调用getDocument（）方法返回所维护的文档，注意这里是文本区所维护的文档能出发DocumentEvent事件。 2 注册监视器 能触发DocumentEvent事件的事件源使用addDocumentListener(DocumentListener listener)将实现DocumentListener接口的类的实例注册为事件...
Java------JTable的使用
hello_cmy的博客
07-09 3786
JTable，表格。JTable 是用来显示和编辑常规二维单元表。 表格组件和其他普通组件一样，需要添加到中间容器中才能显示，添加表格到容器中有两种方式: 添加到普通的中间容器中（如上面代码实例所示的添加到JPanel），此时添加的jTable只是表格的行内容，表头(jTable.getTableHeader())需要额外单独添加。此添加方式适合表格行数确定，数据量较小，能一次性显...
Java多线程：生产者消费者问题详解与解决方案
- **数据共享问题**：生产者和消费者需要访问缓冲区，需用synchronized关键字保证同一时间只有一个线程能操作缓冲区。 - **Clerk类设计**：包含方法如`enqueue()`（生产者放入产品）、`dequeue()`（消费者取出产品...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值