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

最新推荐文章于 2024-08-07 09:14:10 发布
最新推荐文章于 2024-08-07 09:14:10 发布
阅读量463 收藏
点赞数 1
分类专栏： JUC 文章标签： java javascript 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53374893/article/details/132916231
版权

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

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

package com.kuang.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 num = 0;

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

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

}

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

package com.kuang.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();


        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 Data{//数字  资源类
    private  int num = 0;

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

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

}

 

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

 

package com.kuang.pc;

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

/**
 * 线程之间的通信问题，生产者和消费者问题！ 等待唤醒 ，通知唤醒
 * 线程交替执行 A B 操作同一个变量 num=0
 * A num+1;
 * B num-1;
 */
public class B {

    public static void main(String[] args) {
        Data1 data = new Data1();
        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 Data1 {//数字  资源类
    private int num = 0;

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


    }

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


    }

}

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

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

package com.kuang.pc;

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

/**
 * 线程之间的通信问题，生产者和消费者问题！ 等待唤醒 ，通知唤醒
 * 线程交替执行 A B 操作同一个变量 num=0
 * A num+1;
 * B num-1;
 */
public class C {

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

        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 Data2 {//数字  资源类


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

    private int num=1;
    public void printA(){
        lock.lock();
        try {
            if (num!=1){
                //等待
                condition1.await();
            }
            num=2;
            System.out.println(Thread.currentThread().getName()+":Aaa");
         //唤醒，唤醒指定的人，B
           condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }


    }
    public void printB(){
        lock.lock();
        try {
            if (num!=2){
                condition2.await();
            }
            num=3;
            System.out.println(Thread.currentThread().getName()+":Bbb");
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
    public void printC(){
        lock.lock();
        try {
            if (num!=3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+":Ccc");
            num=1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

}

精准唤醒线程  Condition

荭色海湾
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【JUC基础】06. 生产者和消费者问题
有一只柴犬的专栏
05-15 847
学习JUC，就不得不提生产者消费者。生产者消费者模型是一种经典的多线程模型，用于解决生产者和消费者之间的数据交换问题。在生产者消费者模型中，生产者生产数据放入共享的缓冲区中，消费者从缓冲区中取出数据进行消费。在这个过程中，生产者和消费者之间需要保持同步，以避免数据出现错误或重复。今天我们就来说说生产者消费者模型，以及JUC中如何解决该模型的同步问题。
【多线程】生产者消费者传统版和阻塞队列版
李光 未来科技
03-07 239
前言 等待与唤醒机制其实就是经典的生产者与消费者问题 我们知道，生产者要想和消费者作用在一件产品上，必须要用到锁机制。通过锁机制保证一个产品同一时间只有一个角色在执行。 下面将分别使用Synchronized和Lock锁解决生产者和消费者的问题。 1Synchronized版 /** * 线程之间的通信问题：生产者与消费者问题！ * A和B操作同一个变量，线程交替执行，num=0 * A num+1 * B num-1 */ public class A { public static v
【多线程】生产者消费者问题（Synchronized和Lock版本实现）
历乱的日记簿
05-05 119
一、Synchronized和Lock 【追根溯源】Sychronized 是Java内置的关键字，而Lock是一个类 【自动挡与手动挡】Sychronized 自动释放锁，而Lock是手动释放（unlock）。（假如没有手动释放，就会造成死锁） 【锁的状态】Sychronized 不能获取锁的状态，Lock可以； 【在一棵树上吊死】Sychronized 当一个线程获取资源的锁，那么另外想要该资源的线程会一直等待，而Lock有tryLock，超时放弃等待； 【锁的量】Sychronized 适用于锁少量
生产者与消费者的问题（线程的替换）
m0_69114709的博客
04-05 74
我们用到sychronized锁，this.wait()方法就是让该线程进入休眠状态，并释放自己的锁，this.notiflyAll()通知其他的线程进入锁状态。
用阻塞队列实现一个生产者消费者模型？synchronized和lock有什么区别？
yuxue的博客
07-10 166
多线程当中的阻塞队列 主要实现类有 ArrayBlockingQueue是一个基于数组结构的有界阻塞队列，此队列按FIFO原则对元素进行排序 LinkedBlockingQueue是一个基于链表结构的阻塞队列，此队列按FIFO排序元素，吞吐量通常要高于ArrayBlockingQueue SynchronousQueue是一个不存储元素的阻塞队列，单个插入操作必须等到另一个线程调用移除操作，否则插 入操作一直处于阻塞状态 1. 阻塞队列概念 阻塞队列通俗来说，是一个队列，而一个阻塞队列再数据结构中所起的
01Lock锁
niannujiao6的博客
07-11 535
线程：对于Java而言，Thread 、Runnable、CallableJava是开启不了线程的，需要调用本地C++的方法启动硬件来开启线程。并发：多线程操作同一个资源（CPU单核） 并行：多条任务一起行走（CPU多核）获取CPU核数 并发编程本质：要充分利用CPU资源处理任务sleep与wait的区别以多线程卖票为例： 不难看出，多线程卖票在不加锁的情况下操作统一资源很容易出错。 解决1：传统解决方法是在同步代码中加入Sychronized锁：...
萌新必入！手把手教你玩转Synchronized锁和Lock锁！
热门推荐
sid10t.
08-20 3万+
文章目录声明前言Synchronized锁Lock锁Synchronized与Lock区别生产者与消费者问题SynchronizedLock8锁现象后记 声明 1）该文章部分内容整理自网上的资料，如不小心侵犯了大家的权益，还望海涵，并联系博主删除。 2）博主是萌新上路，文中如有不当之处，请各位大佬指出，共同进步，谢谢。   前言 这是一篇关于 Synchronized 锁和 Lock 锁的超详细的万字博文，博文中列举了大量的例子用于理解，相信深度阅读本博文后，玩转 Synchronized 锁和
面试：生产者消费者
qq_45981158的博客
04-19 59
面试：生产者消费者 （生产者消费者，思索，单例，八大排序） 传统版 sychronized wait notify public class test { public static void main(String[] args) { A a =new A(); new Thread(()->{ for (int i = 0; i < 5; i++) { try {
总结：一文死磕 synchronized 和 AQS 系
哎幽的成长
12-11 5143
先将ReentrantLock跟常用的Synchronized进行比较，其特性如下 ReentrantLock Synchronized 锁实现 依赖AQS 监视器Monitor模式 灵活性 支持响应中断、超时、尝试获取锁 不灵活 释放形式 必须显示的调用unlock()释放锁 自动释放监视器 锁类型 公平锁&非公平锁 非公平锁 条件队列 可关联多个队列 关联一个条件队列 可重入性 可重入 可重入 1. synchronized synchronized关键
J031_使用TCP协议支持与多个客户端同时通信
lzn20161229的博客
08-03 433
使用TCP协议支持与多个客户端同时通信。
【Spring Boot】高效配置管理: 易用性与灵活性并重
weixin_68020300的博客
08-07 917
本文探讨了Spring Boot中多样化的配置读取方法及其应用场景，强调了配置管理的重要性，并展示了Spring Boot如何通过灵活多变的配置选项简化这一过程。此外，文章还展望了配置管理领域未来的技术趋势和发展方向。对于任何希望深入了解Spring Boot配置管理的开发者来说，这是一篇不容错过的好文。
C++ - 函数重载
jiaowenjie的专栏
08-06 197
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
伐木工 (100%用例)D卷 (Java&&Python&&C++&&Node.js&&C语言)
最新发布
荆赫同艺的博客
08-07 43
一根 4米长的树木，伐木工不需要切割为 2*2，省去切割成本，直接整根树木交易，为 4*1，收益最大为 4。方式二: 3,2,2,3，但方式二，伐木工多切割一次，增加了切割成本却卖了一样的价格，因此并不是最优收益。一根 2 米长的树木，伐木工不切割，为2*1，收益最大为 2。一根5 米长的树木，伐木工切割为 2*3,收益最大为 6。输出最优收益时的各个树木长度，以空格分隔，按升序排列。一根 10 米长的树木，伐木工可以切割。方式一:3,4,4，也可以切割为。
枚举工具类
qq_43049583的博客
08-04 438
java枚举工具类
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
m0_74283290的博客
08-03 1268
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
等待唤醒机制两种实现方法-阻塞队列
泰勒今天想展开的博客
08-04 511
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
Servlet(2)
xjdkxnhcoskxbco的博客
08-04 754
这个注解可以用来修饰一个Servlet类，可以简化配置，替代Web.xml中 的servlet配置。
string类的模拟实现(C++)
2302_80190394的博客
08-02 1148
C++ string的功能函数实现
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值