JUC练习代码-JUC版本实现生产者消费者问题

最新推荐文章于 2022-08-27 17:18:20 发布
最新推荐文章于 2022-08-27 17:18:20 发布
阅读量226 收藏 1
点赞数
分类专栏： 高并发多线程（Java提升篇）
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qiruibbb/article/details/106928838
版权 
public class JUCTest02 {
    public static void main(String[] args) throws InterruptedException {
        Data2 data = new Data2();
        new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "C").start();
        new Thread(() -> {
            for (int i = 0; i < 20; 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();

    public void increment() throws InterruptedException {
        lock.lock();
        try {

            while (number > 0) {
                //等待
                System.out.println(Thread.currentThread().getName() + "wait");
                condition.await();
            }
            number++;

            //通知其他线程，我+1完毕了
            System.out.println(Thread.currentThread().getName() + "执行了+1" + ";number=" + number);
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();

        } finally {
            lock.unlock();
        }


    }

    public void decrement() throws InterruptedException {
        lock.lock();
        try {

            while (number <= 0) {
                //等待
                System.out.println(Thread.currentThread().getName() + "wait");
                condition.await();
            }
            number--;
            //通知其他线程，我+1完毕了
            System.out.println(Thread.currentThread().getName() + "执行了-1" + ";number=" + number);
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }


    }
}

编写代码时注意顺序，首先是lock.lock()，然后try 里面包括业务逻辑，最后finally lock.unlock()
Condition也是JUC包下接口，可以通过lock.newCondition()进行实例化。
Condition中await，signal ，signalAll方法，对应Object的wait，notify，notifyAll方法。

上述代码样例打印的部分结果如下所示

A执行了+1;number=1
Await
B执行了-1;number=0
Bwait
A执行了+1;number=1
Await
B执行了-1;number=0
Bwait
C执行了+1;number=1
Cwait
Await
B执行了-1;number=0
Bwait

虽然满足0，1输出，但是怎么保证ABCD也是按照顺序打印呢？

其实只要创建多个condition对象，就可以精确等待和唤醒了。如下图代码所示：

public class JUCTest02 {
    public static void main(String[] args) throws InterruptedException {
        Data2 data = new Data2();
        new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                try {
                    data.increment1();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                try {
                    data.decrement2();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                try {
                    data.increment3();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "C").start();
        new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                try {
                    data.decrement4();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "D").start();

    }
}

//判断是否等待，业务，干完活通知
class Data2 {
    private int number = 0;
    Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();
    Condition condition4 = lock.newCondition();

    public void increment1() throws InterruptedException {
        lock.lock();
        try {

            while (number > 0) {
                //等待
                System.out.println(Thread.currentThread().getName() + "wait");
                condition1.await();
            }
            number++;

            //通知其他线程，我+1完毕了
            System.out.println(Thread.currentThread().getName() + "执行了+1" + ";number=" + number);
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();

        } finally {
            lock.unlock();
        }


    }

    public void decrement2() throws InterruptedException {
        lock.lock();
        try {

            while (number <= 0) {
                //等待
                System.out.println(Thread.currentThread().getName() + "wait");
                condition2.await();
            }
            number--;
            //通知其他线程，我+1完毕了
            System.out.println(Thread.currentThread().getName() + "执行了-1" + ";number=" + number);
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }


    }

    public void increment3() throws InterruptedException {
        lock.lock();
        try {

            while (number > 0) {
                //等待
                System.out.println(Thread.currentThread().getName() + "wait");
                condition3.await();
            }
            number++;

            //通知其他线程，我+1完毕了
            System.out.println(Thread.currentThread().getName() + "执行了+1" + ";number=" + number);
            condition4.signal();
        } catch (Exception e) {
            e.printStackTrace();

        } finally {
            lock.unlock();
        }


    }

    public void decrement4() throws InterruptedException {
        lock.lock();
        try {

            while (number <= 0) {
                //等待
                System.out.println(Thread.currentThread().getName() + "wait");
                condition4.await();
            }
            number--;
            //通知其他线程，我+1完毕了
            System.out.println(Thread.currentThread().getName() + "执行了-1" + ";number=" + number);
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }


    }

部分打印结果，如下所示：

A执行了+1;number=1
Await
B执行了-1;number=0
Bwait
C执行了+1;number=1
Cwait
D执行了-1;number=0
Dwait
A执行了+1;number=1
Await
B执行了-1;number=0
Bwait
C执行了+1;number=1
Cwait
D执行了-1;number=0
Dwait
A执行了+1;number=1
Await
B执行了-1;number=0
Bwait
C执行了+1;number=1
Cwait
D执行了-1;number=0
Dwait
A执行了+1;number=1
Await
B执行了-1;number=0
Bwait
C执行了+1;number=1
Cwait
D执行了-1;number=0
Dwait
A执行了+1;number=1
Await
B执行了-1;number=0
Bwait
C执行了+1;number=1
Cwait
D执行了-1;number=0
Dwait
A执行了+1;number=1
Await
B执行了-1;number=0
Bwait
C执行了+1;number=1
Cwait
D执行了-1;number=0
Dwait
老张聊天
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
juc-jenkins-2018:JUC Jenkins 2018演示源代码
05-11
juc-jenkins-2018 JUC Jenkins 2018演示源代码 先决条件 为了运行此演示，必须有一个有效的JDK，git命令以及curl。 克隆存储库 将此存储库克隆到您家中的某个位置： git clone ...
狂神说JUC代码狂神说JUC代码
09-11
【狂神说JUC代码】是一系列专注于Java并发编程（JUC，Java Util Concurrency）的教程或笔记，旨在帮助开发者深入理解并掌握Java平台上的并发处理机制。JUC是Java标准库中的一组高级并发工具类，为多线程环境下的程序...
JUC并发编程
weixin_42522705的博客
08-27 98
JUC并发编程
JUC习题
qq_34446716的博客
10-22 446
练习JUC的题目 语言：Java 来源：LeetCode 打印奇偶数 使用sem比lock要简单一些 class ZeroEvenOdd { private int n; Semaphore zero = new Semaphore(1); Semaphore even = new Semaphore(0); Semaphore odd = new Semaphore(0); volatile int flag = 1; public ZeroEvenOdd
Juc_无juc情况
959
03-02 464
Synchronized和Lock的区别 import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; class Ticket{ private int number = 30; private Lock lock = new ReentrantLock(); public void sale(){ lock.lock(); tr
Java多线程 JUC并发编程 （第二天）
别訆我小内脏的博客
06-13 1189
多线程进阶=>JUC并发编程 9、读写锁 ReadWriteLock 代码实现 package com.feimai.test.JUCTest.rw; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLo.
JUC练习，以及死锁和Lock（锁)的学习记录
weixin_52725999的博客
02-10 141
JUC并发包 package com.lean.syn; import java.util.concurrent.CopyOnWriteArrayList; //测试JUC安全类型的集合 public class TestJUC { public static void main(String[] args) { CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
heima-JUC-资料
最新发布
04-25
在Java中，JUC包（java.util.concurrent）包含了一系列的类和接口，这些类和接口主要用于解决并发问题，如线程池、同步容器、并发集合、锁、原子变量等。下面我们将深入探讨这些关键概念： 1. **线程池**：Java通过...
A-JUC-JVM-Java并发知识..pdf
06-05
互联网大厂开发高频面试及知识点总结 涉及JUC 包下的并发相关知识梳理 JVM及参数调优案例等
个人学习-JUC-笔记
02-25
- **BlockingQueue**：阻塞队列，常用于生产者-消费者模型，如ArrayBlockingQueue、LinkedBlockingQueue。 6. **原子类** - **Atomic包**：如AtomicInteger、AtomicLong等，提供原子操作，避免显式锁定。 7. **...
个人学习JUC代码笔记总集
07-27
个人学习的时候对JUC做的笔记，包括所有代码，学习视频是尚硅谷周阳老师的JUC，需要有一定的基础才能看懂，这是个人笔记，不一定适用于所有人，谢谢！
JUC并发编程学习笔记（狂神）
热门推荐
weixin_44491927的博客
09-13 1万+
目录JUC并发编程1. 什么是JUC2. 线程和进程1）进程2）线程3）并发4）并行5）线程的状态6）wait/sleep3.Lock1）传统的 synchronized2）Lock3. Synchronized 与Lock 的区别4. 生产者和消费者的关系1）Synchronzied 版本2）存在问题（虚假唤醒）3）Lock版4）Condition的优势5. 8锁现象6. 集合不安全1）List 不安全2）set 不安全3）Map不安全7. Callable8. 常用的辅助类1）CountDownLatc
JUC代码理解
初级知识储备博客
03-11 415
JUC简单基础代码的理解
【狂神Java笔记】JUC并发（附代码）（更新中……）
Blue
02-26 596
目录JUC并发1、什么是JUC？2、线程和进程并发、并行线程有几个状态：wait / sleep区别3、Lock锁(重点)传统 SynchronizedLock锁Synchronized和Lock区别锁是什么,如何判断锁得是谁！4、生产者和消费者问题Synchronized版JUC版5、8锁现象代码Text 1Text 2Text 3Text 4小结6、集合类不安全list 不安全set 不安全map 不安全7、callable （简单） JUC并发 1、什么是JUC？ java.util 工具包、
JUC源码学习
w7486的博客
02-23 989
目录 1.Lock ReentrantLock源码解析 公平锁和非公平锁的区别 什么是AQS Synchronized和Lock的区别 2.Condition( 线程通信) 3.BlockQueue阻塞队列 4.CountDownLatch 5.Semaphore(信号灯) 6.Atomic原子类 1.Lock Lock是JUC下控制锁的接口，它要比前面用到的Synchronized更加灵活。 他有一些方法 lock()加锁 unlock()释放锁，它与lock()配套使用
深入JUC源码看锁
PYXLY1314的专栏
05-19 440
锁，相信大家都听过也用过。如下伪代码： Lock lk = new Lock(); try{ lk.lock(); // 不为人知的代码块… … } finally { lk.unLock(); } FAQ: 用起来简单丝滑有没有？但是请仔细思考一下如下几个问题： 什么场景下用它？ 它帮我们解决了啥问题？ 为啥区区一个锁就能解决这个问题，它为何这么diao，用了啥技术？ 一般情况下只有在“并发”访问“共享”资源情况下，...
JAVA-JUC的代码学习笔记-练习可以提高，java代码
java技术专家全栈成长之路
01-14 359
自己学习的时候可以自定义注解可以学习用，标志方便清晰； RetentionPolicy.SOURCE -- 加载不运行 注解1，不推荐写法 /** * 课程里用来标记【不推荐】的类或者写法 */ @Target(ElementType.TYPE) @Retention(RetentionPolicy.SOURCE) public @interface NotRecommend { ...
juc
调皮的写代码
05-27 1016
一、juc是什么？二、
【JUC学习】——生产者消费者问题
时光、疏离了记忆づ童话的博客
01-21 271
  生产者消费者问题用于很好的解释线程间通信的问题，大致意思可以解释为如果货架上物品为空，则通知生产者开始生产物品，如果货架上的物品满了，就通知消费者进行消费。在JUC中实现主要是通过synchronized和lock实现，对于synchronized，一般采用wait（等待）和notify（唤醒）进行线程的同步通信。在juc并发包下对应的lock方法为await和signal，同时使用资源监视器Condition来进行精准唤醒。 一、Synchronized（wait和notify） 下面看一下第一版的
"Java-JUC-多线程 进阶：遇见狂神说的JUC并发编程进阶版概要
这是一种常见的并发编程模式，可以实现一个生产者线程和一个消费者线程之间的数据交互。通过使用锁和条件变量，生产者线程可以将数据放入队列，而消费者线程可以从队列中取出数据。这个模式可以很好地解决多线程间的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值