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

这篇具有很好参考价值的文章主要介绍了传统生产者和消费者问题,Sychronized版和Lock版。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

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判断之后被唤醒,没判断条件被执行了两次增加,导致的虚假唤醒问题。 

传统生产者和消费者问题,Sychronized版和Lock版,JUC,java,javascript,开发语言

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();
    }

}

 传统生产者和消费者问题,Sychronized版和Lock版,JUC,java,javascript,开发语言

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

传统生产者和消费者问题,Sychronized版和Lock版,JUC,java,javascript,开发语言

 

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 优势精准通知,唤醒线程

传统生产者和消费者问题,Sychronized版和Lock版,JUC,java,javascript,开发语言

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文章来源地址https://www.toymoban.com/news/detail-731565.html

到了这里,关于传统生产者和消费者问题,Sychronized版和Lock版的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【Linux】cp问题,生产者消费者问题代码实现

    生产者消费者模式就是通过一个容器 来解决生产者和消费者的强耦合问题 。生产者和消费者彼此之间不直接通讯,而通过阻塞队列来进行通讯,所以生产者生产完数据之后不用等待消费者处理,直接扔给阻塞队列,消费者不找生产者要数据,而是直接从阻塞队列里取,阻塞

    2024年02月04日
    浏览(36)
  • 【课设】生产者-消费者问题算法 的设计与实现

    题目:生产者-消费者问题算法 的设计与实现 目     录 1. 课题概述 ... 2 2. 合作分工 ... 2 3. 相关知识 ... 2 4. 系统分析 ... 2 5. 系统设计 ... 2 6. 系统运行测试界面截图 ... 2 7. 总结与心得体会 ... 2 8. 源程序清单 ... 2   1.    课题概述 1.1设计的目的和要求; 在现代软件业的发

    2024年02月08日
    浏览(42)
  • Linux操作系统实验:生产者和消费者问题

    “生产者消费者”问题是一个著名的同时性编程问题的集合。通过编写经典的”生产者消费者”问题的实验,读者可以进一步熟悉 Linux 中多线程编程,并且掌握用信号量处理线程间的同步互斥问题。 VMware Workstation Pro “生产者消费者”问题描述如下。 有一个有限缓冲区和两

    2024年02月06日
    浏览(58)
  • JUC并发编程学习笔记(三)生产者和消费者问题

    synchronized版- wait/notify juc版-Lock 面试:单例模式、排序算法、生产者和消费者、死锁 生产者和消费者问题 Synchronized版 存在的问题:A、B、C、D四个线程 在线程中判断业务完成唤醒等待应该使用while循环判断,而非if判断,因为if判断值判断一次,在线程中存在一种状态叫虚假唤

    2024年02月06日
    浏览(38)
  • 12.3用信号量进行线程同步——生产者与消费者问题

    1.shell程序设计 2.内存管理 3.链接库 4.文件操作

    2024年02月04日
    浏览(41)
  • JUC并发编程-线程和进程、Synchronized 和 Lock、生产者和消费者问题

    源码 + 官方文档 面试高频问! java.util 工具包、包、分类 业务:普通的线程代码 Thread Runnable Runnable 没有返回值、效率相比入 Callable 相对较低! 线程、进程,如果不能使用一句话说出来的技术,不扎实! 进程:一个程序,QQ.exe Music.exe 程序的集合; 一个进程往往可以包含多

    2024年01月20日
    浏览(51)
  • C++实现经典同步问题(生产者消费者、读者写者、哲学家进餐、吸烟者问题)

    环境:windows 问题描述: 一组生产者进程和一组消费者进程共享一个初始为空、大小为〃的缓冲区,只有缓冲区没满时,生产者才能把消息放入缓冲区,否则必须等待;只有缓冲区不空时,消费者才能从中取出消息,否则必须等待。由于缓冲区是临界资源,它只允许一个生产

    2023年04月23日
    浏览(36)
  • 详解经典进程同步问题(生产者消费者问题/哲学家进餐问题/读者写者问题)_OS

    目录 1. 利用信号量实现进程的同步和互斥 利用信号量实现进程互斥 利用信号量实现进程同步 2. 生产者消费者问题 3. 哲学家就餐问题 4. 读者写者问题 读者优先 写者优先 读者写者问题的变形 使用信号量解决读者写者问题 5. 经典同步问题例题 6. 管程机制 使用管程解决生产者

    2023年04月10日
    浏览(42)
  • 生产者-消费者模型

    目录 1、生产者-消费者模型是什么 2、Java中的实现 3、应用于消息队列 3.1 引入依赖 3.2 rabbitmq网站新建队列queue 3.3 模块中配置application.yml 3.4 生产者实现类 3.5 单元测试,发送msg到rabbitmq的队列(my_simple_queue) 3.6 消费者实现类 3.7 从rabbitmq队列(my_simple_queue)消费数据 3.8 队列的配

    2024年02月06日
    浏览(42)
  • Python多线程Thread——生产者消费者模型 python队列与多线程——生产者消费者模型

    下面面向对象的角度看线程 那么你可以试试看能不能用面向对象的方法实现生产者消费者模型吧。

    2024年02月09日
    浏览(56)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包