JUC（生产者消费者模型、Lock&Condition）

最新推荐文章于 2022-10-17 22:09:41 发布
最新推荐文章于 2022-10-17 22:09:41 发布
阅读量147 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63544124/article/details/125734207
版权

目录

1. 信号灯法（Synchronized实现）

解决虚假唤醒​编辑

2. 信号灯法（Lock实现）

2.1 基本实现

2.2 Condition精准通知

3 管程法

 

1. 信号灯法（Synchronized实现）

public class PCDemo {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.produce();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

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

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

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

    }
}

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

    //+1
    public synchronized void produce() throws InterruptedException {
        //1.判断等待
        while (number != 0) {  // ！！！！！！注意解决虚假唤醒，必须用while，不能用if
            wait();
        }
        //2.业务
        number++;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        //3.通知
        this.notifyAll();
    }

    //-1
    public synchronized void consum() throws InterruptedException {
        //1.判断等待
        while (number == 0) {  // ！！！！！！注意解决虚假唤醒，必须用while，不能用if
            wait();
        }
        //2.业务
        number--;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        //3.通知
        this.notifyAll();
    }
}

解决虚假唤醒

2. 信号灯法（Lock实现）

2.1 基本实现

 

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

public class Data2 {
    private int number = 0;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    //+1
    public void produce() throws InterruptedException {
        lock.lock();
        try {
            //1.判断等待
            while (number != 0) {// ！！！！！！注意解决虚假唤醒，必须用while，不能用if
                condition.await();
            }
            //2.业务
            number++;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            //3.通知
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

    //-1
    public void consum() throws InterruptedException {
        lock.lock();
        try {
            //1.判断等待
            while (number == 0) {
                condition.await();
            }
            //2.业务
            number--;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            //3.通知
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

2.2 Condition精准通知


public class PCDemo3 {
    public static void main(String[] args) {
        Data3 data = new Data3();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.produceA();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();

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

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

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

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

public class Data3 {
    private int number = 1;
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    private Condition condition4 = lock.newCondition();
    //执行顺序：A->B->C->D

    //+1
    public void produceA() throws InterruptedException {
        lock.lock();
        try {
            //1.判断等待
            while (number != 1) {// ！！！！！！注意解决虚假唤醒，必须用while，不能用if
                condition1.await();
            }
            //2.业务
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            number = 2;
            //3.通知
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }


    //-1
    public void consumB() throws InterruptedException {
        lock.lock();
        try {
            //1.判断等待
            while (number != 2) {
                condition2.await();
            }
            //2.业务
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            number = 3;
            //3.通知
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }


    //+1
    public void produceC() throws InterruptedException {
        lock.lock();
        try {
            //1.判断等待
            while (number != 3) {// ！！！！！！注意解决虚假唤醒，必须用while，不能用if
                condition3.await();
            }
            //2.业务
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            number = 4;
            //3.通知
            condition4.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }


    //-1
    public void consumD() throws InterruptedException {
        lock.lock();
        try {
            //1.判断等待
            while (number != 4) {
                condition4.await();
            }
            //2.业务
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            number = 1;
            //3.通知
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

3 管程法

 

 

m0_63544124
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java多线程实现简单消费者生产者模型
XuXuemin的专栏
03-30 170
介绍Java多线程实现生产者消费者简单模型
【JUC基础】06. 生产者和消费者问题
有一只柴犬的专栏
05-15 846
学习JUC，就不得不提生产者消费者。生产者消费者模型是一种经典的多线程模型，用于解决生产者和消费者之间的数据交换问题。在生产者消费者模型中，生产者生产数据放入共享的缓冲区中，消费者从缓冲区中取出数据进行消费。在这个过程中，生产者和消费者之间需要保持同步，以避免数据出现错误或重复。今天我们就来说说生产者消费者模型，以及JUC中如何解决该模型的同步问题。
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 - 多线程之Synchronized和Lock锁；生产者消费者模式（一）
MinggeQingchun的博客
10-17 568
JUC首先，再简单说一下并行、并发；进程、线程。
Java学习之线程--死锁-生产者消费者模式
申公的专栏
03-08 3515
一、过多的同步会导致死锁 二、生产者消费者模式： 生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后
多线程以及juc,lock
07-20
多线程以及juc,lock
JUC并发编程视频教程
11-28
视频详细讲解，需要的小伙伴自行网盘下载，链接见附件，永久有效...进程与线程第三章：Java 线程第四章：共享模型之管程第五章：共享模型之内存第六章：共享模型之无锁第七章：共享模型之不可变第八章：共享模型之工具
juc多线程交替打印ABC、熟悉lock的唤醒机制
07-10
现场交替访问、等待和唤醒
juc详解juc详解juc详解juc详解juc详解juc详解juc详解
最新发布
08-02
- `LinkedBlockingQueue`：有界的阻塞队列，适用于生产者-消费者模型。 4. **同步器**： - `CountDownLatch`：计数器，用于等待多个线程完成操作后再继续执行。 - `CyclicBarrier`：回环栅栏，允许一组线程等待...
狂神说JUC代码狂神说JUC代码
09-11
- **BlockingQueue**：阻塞队列，是一种特殊的线程安全的数据结构，当队列满时，生产者线程会被阻塞；当队列空时，消费者线程会被阻塞。 5. **原子类**：如AtomicInteger、AtomicLong等，它们提供了一种无锁的原子...
生产者消费者模式之Lock与Condition
xiaoyaoLee1955
02-15 686
        在synchronized中解决线程间通信的生产者消费者问题可以使用Object类的wait()和notify()/notifyAll()方法（可参考），但是我在《同步之Lock锁》中说过Lock是对synchronized的一种更为面向对象的替代，如果我们使用Lock来解决生产者消费者问题又将怎样编写代码呢？在JDK1.5中提供的Condition配套Lock可以实现相同的功能，...
Java并行编程-lock中使用多条件condition（生产者消费者模式实例）
热门推荐
记忆力不好的博客
06-05 2万+
Java 并发包下的提供Lock，Lock相对于Synchronized可以更好的解决线程同步问题，更加的灵活和高效，并且ReadWriteLock锁还能实现读、写的分离。但线程间仅仅互斥是不够的，还需要通信，本篇的内容是基于上篇之上，使用Lock如何处理线程通信。阻塞队列(BlockingQueue)就是使用condition的和lock实现的。可以查看：Java并发编程-阻塞队列(Blockin
生产者&消费者（Lock）
qq_41517711的博客
11-18 228
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(()-&
多线程之生产者与消费者问题
m0_49562228的博客
09-02 479
1.问题概述 生产者消费者问题（Producer-consumer problem），也称有限缓冲问题（Bounded-buffer problem），是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。 2.解决方案 要解决该
JUC：生产者消费者模式
weixin_48410604的博客
07-26 160
文章目录虚假唤醒（spurious wakeup）生产者与消费者模板生产者与消费者模式：synchronized 虚假唤醒（spurious wakeup） 当需要条件判断使用wait()方法时，应该使用循环，而不是if，否则就可能会出现虚假唤醒（spurious wakeup）的情况 简单点理解，虚假唤醒就是除了理应被唤醒的线程之外，还另外唤醒了其它的线程，导致的数据的错误 虚假唤醒的原理： 例： public class Test10 { public static void main(Stri
JUC学习之生产者消费者案例-Lock-Condition线程通信
dyt443733328的博客
04-19 223
本文是看视频学习笔记，若有错误请指正！生产者消费者案例的lock写法其中涉及到了Condition的用法，简答的介绍一下：1.Condition接口描述了可能会与锁相关的条件变量，这些变量在用法上与使用Object.wait访问的隐式监视器类似，但提供了更强大的功能。需要特别之处的是，单个lock可能会与多个Condition对象关联，为了避免兼容性问题，Condition方法的名称与对应的Obj...
JUC-7.生产者消费者案例-虚假唤醒
xbliu564的博客
03-11 421
1. 生产者和消费者案例 以下为生产者和消费者共享店员进行进货和售货的案例，生产者在库存已满时也不停进货，消费者在库存为0时也不停售货。 那么在实际生产中，就会造成生产者在库存已满时进货，造成数据丢失。消费者也会在不停的消费。 /** * 生产者和消费者案例 * @author xiaobin * @date 2018/3/11 */ public class TestProdu...
JUC之生产者与消费者问题
OriSu
05-20 300
一、简介 生产者与消费者问题主要是涉及到线程间通信的问题，以一个简单案例为例，初始没有产品，生产者生产了产品，就要消费者去消费，消费者消费完再让生产者继续生产 二、Synchronized版本 package P_C.Synchronized; public class TestPC { public static void main(String[] args) { Data data = new Data(); new Thread(()->{
JUC详解2——生产者消费者
qq_41510551的博客
10-24 226
JUC详解2生产者消费者使用synchronized方法解决使用lock解决生产者消费者问题高频面试题：一个主线程三个子线程，如何让三个子线程执行结束再执行主线程 生产者消费者 线程间的通信问题——生产者消费者问题 一个简单的生产者消费者模型（使用synchronized） 使用synchronized方法解决 package com.fly.juc.pc; /** * @Description 生产者、消费者 * 线程间通信问题————生产者、消费者问题：等待唤醒；通知唤醒 * 线程交替执行：P：
JUC与生产者消费者
业精于勤荒于嬉 行成于思毁于随
01-20 433
前面一篇文章介绍了生产者消费者模式，这篇来看看JUC包下的哪些类与该模式有关。 生产者消费者模式中有个中间类Channel，对于数据Data起到通道作用，还确保了Producer与Consumer这些线程的协调运行。在前篇文章所举的例子中的Table类担任这个角色，内部是使用数组实现的队列配合synchronized关键字。而在JUC包下提供了BlockingQueue接口及其实现类，它们相当于C...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值