手写生产者与消费者

已于 2022-06-15 19:31:03 修改
阅读量347 收藏 1
点赞数
分类专栏： Java 文章标签： java 面试
于 2022-06-14 21:21:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40301475/article/details/125286256
版权

手写生产者与消费者

使用synchroinzed与ReentrantLock完成手写生产者与消费者

狂神说Java学习笔记

生产者和消费者 synchroinzed 版

/**
 * Created by Xumx on 2022/6/14 20:25
 *
 *         生产者和消费者 synchroinzed 版
 *
 * 题目：现在两个线程，可以操作初始值为0的一个变量
 *  实现一个线程对该变量 + 1，一个线程对该变量 -1
 *  实现交替10次
 *
 *  诀窍：
 *  1. 高内聚低耦合的前提下，线程操作资源类
 *  2. 判断 、干活、通知
 */

public class Test1 {

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

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

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

}

class Data{
    private  int number = 0;

    public synchronized void increment() throws InterruptedException {
        while (number!=0){
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        this.notifyAll();
    }

    public synchronized void decrement() throws InterruptedException {
        while (number==0){
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        this.notifyAll();
    }

}

问题升级：4个线程，两个加，两个减

/**
 * Created by Xumx on 2022/6/14 20:34
 *
 *      synchroinzed 版
 * 题目：现在四个线程，可以操作初始值为0的一个变量
 * 实现两个线程对该变量 + 1，两个线程对该变量 -1
 * 实现交替10次
 *
 * 诀窍：
 * 1. 高内聚低耦合的前提下，线程操作资源类
 * 2. 判断 、干活、通知
 * 3. 多线程交互中，必须要防止多线程的虚假唤醒，也即（判断不能用if，只能用while）
 */

public class Test2 {
    public static void main(String[] args) {
        final Data data = new Data();

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

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

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

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

}

class Data{
    private  int number = 0;

    public synchronized void increment() throws InterruptedException {
        while (number!=0){
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        this.notifyAll();
    }

    public synchronized void decrement() throws InterruptedException {
        while (number==0){
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        this.notifyAll();
    }

}

ReentrantLock版生产者和消费者写法

/**
 * Created by Xumx on 2022/6/14 20:48
 *
 *      ReentrantLock版生产者和消费者写法
 * 题目：现在四个线程，可以操作初始值为0的一个变量
 * 实现两个线程对该变量 + 1，两个线程对该变量 -1
 * 实现交替10次
 * <p>
 * 诀窍：
 * 1. 高内聚低耦合的前提下，线程操作资源类
 * 2. 判断 、干活、通知
 * 3. 多线程交互中，必须要防止多线程的虚假唤醒，也即（判断不能用if，只能用while）
 */
public class Test3 {
    public static void main(String[] args) {
        Data data = new Data();

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

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

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

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

}

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

    public void increment() throws InterruptedException {
        lock.lock();
        try {
            while (number!=0){
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName()+"\t"+number);
            condition.signalAll();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            lock.unlock();
        }
    }

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

        try {
            while (number==0){
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+"\t"+number);
            condition.signalAll();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            lock.unlock();
        }
    }

}

精确通知顺序访问

/**
 * Created by Xumx on 2022/6/14 20:57
 /**
 * 题目：多线程之间按顺序调用，实现 A->B->C
 * 三个线程启动，要求如下：
 * AA 打印5次，BB 打印10次。CC打印15次，依次循环
 *
 * 重点：标志位
 */

public class Test4 {
    public static void main(String[] args) {
        Resources resources = new Resources();
        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                resources.print5();
            }
        },"AA").start();
        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                resources.print10();
            }
        },"BB").start();
        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                resources.print15();
            }
        },"CC").start();
    }
}
class Resources{ // 资源类
    private int number = 1; // 1A 2B 3C
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    public void print5(){
        lock.lock();
        try {
            // 判断
            while (number!=1){
                condition1.await();
            }
            // 干活
            for (int i = 1; i <= 5; i++) {
                System.out.println(Thread.currentThread().getName()+'\t'+i);
            }
            // 通知,指定的干活！
            number = 2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void print10(){
        lock.lock();
        try {
            // 判断
            while (number!=2){
                condition2.await();
            }
            // 干活
            for (int i = 1; i <= 10; i++) {
                System.out.println(Thread.currentThread().getName()+'\t'+i);
            }
            // 通知,指定的干活！
            number = 3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void print15(){
        lock.lock();
        try {
            // 判断
            while (number!=3){
                condition3.await();
            }
            // 干活
            for (int i = 1; i <= 15; i++) {
                System.out.println(Thread.currentThread().getName()+'\t'+i);
            }
            // 通知,指定的干活！
            number = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

手写单例模式

饿汉式

/*
*       饿汉式
*
*   在Hungry类中，如果定义了四个byte数组，当代码一运行，这四个数组就被初始化，并且放入内存了，如
    果长时间没有用到getInstance方法，不需要Hungry类的对象，这不是一种浪费吗？我希望的是 只有用
    到了 getInstance方法，才会去初始化单例类，才会加载单例类中的数据。所以就有了 第二种单例模
    式：懒汉式。
* */
public class Hungry {

    private Hungry(){}

    private final static Hungry hungry = new Hungry();

    public static Hungry getInstance(){
        return hungry;
    }

}

DCL懒汉式

/*
*       懒汉模式
*       lazyMan = new LazyMan();
        不是原子性操作，至少会经过三个步骤：
            1. 分配对象内存空间
            2. 执行构造方法初始化对象
            3. 设置instance指向刚分配的内存地址，此时instance ！=null；
        由于指令重排，导致A线程执行 lazyMan = new LazyMan();的时候，可能先执行了第三步（还没执行第
        二步），此时线程B又进来了，发现lazyMan已经不为空了，直接返回了lazyMan，并且后面使用了返回
        的lazyMan，由于线程A还没有执行第二步，导致此时lazyMan还不完整，可能会有一些意想不到的错
        误，所以增加一个volatile关键字来避免指令重排。
            private volatile static LazyMan lazyMan;
 * */

public class LazyMan {

    private LazyMan(){}

    public static volatile LazyMan lazyMan = null;

    public static LazyMan getLazyMan(){
        if (lazyMan==null){
            synchronized (LazyMan.class){
                if (lazyMan==null){
                    lazyMan = new LazyMan();
                }
            }
        }
        return lazyMan;
    }

	//演示 反射可以破解当前方式的单例
    public static void main(String[] args) throws Exception {
        LazyMan lazyMan = LazyMan.getLazyMan();

        Constructor<LazyMan> constructor = LazyMan.class.getDeclaredConstructor(null);
        constructor.setAccessible(true);
        LazyMan lazyMan2 = constructor.newInstance();

        System.out.println(lazyMan);
        System.out.println(lazyMan2);
        System.out.println(lazyMan==lazyMan2);   // 所以反射是一个比较霸道的东西，无视private修饰的构造方法，可以直接在外面newInstance，破坏我们辛辛苦苦写的单例模式

    }

}

静态内部类实现饿汉式

/*
*       还有这种方式是第一种饿汉式的改进版本，同样也是在类中定义static变量的对象，并且直接初始化，不
        过是移到了静态内部类中，十分巧妙。既保证了线程的安全性，同时又满足了懒加载。
* */

public class LazyMan2 {

    private LazyMan2(){}

    public static LazyMan2 getLazyMan(){
        return InnerClass.lazyMan;
    }

    private static class InnerClass{
        public static final LazyMan2 lazyMan = new LazyMan2();

    }


    //演示 反射可以破解当前方式的单例
    public static void main(String[] args) throws Exception {
        LazyMan2 lazyMan = LazyMan2.getLazyMan();

        Constructor<LazyMan2> constructor = LazyMan2.class.getDeclaredConstructor(null);
        constructor.setAccessible(true);
        LazyMan2 lazyMan2 = constructor.newInstance();

        System.out.println(lazyMan);
        System.out.println(lazyMan2);
        System.out.println(lazyMan==lazyMan2);   // 所以反射是一个比较霸道的东西，无视private修饰的构造方法，可以直接在外面newInstance，破坏我们辛辛苦苦写的单例模式

    }

}

枚举实现饿汉式

public enum LazyMan3 {

    INSTANCE;

    public LazyMan3 getInstance(){
        return INSTANCE;
    }


    public static void main(String[] args) throws Exception {

        LazyMan3 instance1 = LazyMan3.INSTANCE;
        LazyMan3 instance2 = LazyMan3.INSTANCE;

        System.out.println(instance1);
        System.out.println(instance2);

        Constructor<LazyMan3> constructor = LazyMan3.class.getDeclaredConstructor(String.class,int.class);
        constructor.setAccessible(true);
        LazyMan3 instance3 = constructor.newInstance();  //Cannot reflectively create enum objects

        System.out.println(instance3);

    }

}
晒太阳的黑宝
关注
专栏目录
面试官让我手写一个生产者消费者模式
烟雨星空的博客
02-25 1737
不知道你是否遇到过面试官让你手写生产者消费者代码。别说，前段时间有小伙伴还真的遇到了这种情况。当时是一脸懵逼。 但是，俗话说，从哪里跌倒就要从哪里爬起来。既然这次被问到了，那就回去好好研究一下，争取下一次不再被虐呗。 于是，今天我决定手敲一个生产者消费者模式压压惊。（因为我也不想以后被面试官血虐啊） 生产者消费者模式，其实很简单。无非就是生产者不停的生产数据，消费者不停的消费数据。（这不废话吗，字...
手写一个生产者消费者模式
yeguangchen的博客
08-15 657
用wait/notify实现开发者消费者模式，之前博客使用阻塞队列BlockingQueue也实现过开发者消费者模式。 以下的代码和main方法都写在一个文件里就行。 第一步：我们首先需要一个容器storage，我们将它定义为LinkedList是为了使用它的poll方法，一步实现拿出并删除，当然也可以使用ArrayList，然后使用get(0) + remove()拿出删除产品。 这个容器类一个干了三件事，1.定义容器并初始化。2.实现往容器放产品，即创建put方法，供生产者调用。3.实现从容器里取出
手写生产者消费者
qq_32534441的博客
08-06 206
import java.util.ArrayList; import java.util.List; /** * Created with IDEA. * User:haibo. * DATE:2018/7/22/022 */ public class Shop { List<String> data = new ArrayList<String>(); ...
笔记：如何手写一个生产者消费者模型？（入门）
Stayingin的博客
10-09 94
大体分为消费者模型、生产者模型、消息队列模型，其中消息队列模型是最复杂的。生产者模型最基本的可以是使用for循环产生int类型的数字向消息队列中进行添加，即直接调用消息队列类中的add()方法即可。同理，消费者模型就是在消息队列中取出相应的值即可，可以调用消息队列模型中的remove()方法。
Java-手写生产者消费者模式
m0_62448751的博客
04-18 600
【代码】Java-手写生产者消费者模式。
手写一个生产者/消费者模式（三种方式实现）
Virgil_K2017的博客
04-13 8098
这种设计模式需要满足以下三点要求： （1）生产者生产数据到缓冲区中，消费者从缓冲区中取数据。 （2）如果缓冲区已经满了，则生产者线程阻塞； （3）如果缓冲区为空，那么消费者线程阻塞。 编写之前分析： （1）定义一个缓存队列，选择一个集合当做缓存，给予缓存上限，缓存队列只有两种行为（生产数据和消费数据）； （2）定义一个生产者线程，调用缓存队列中的生产行为； （3）定义一个消费者线程，调用缓存队列中...
Java多线程13：手写生产者-消费者模式
何哥的博客
09-12 2164
一、Object的wait、notify和notifyAll方法 1.1、wait方法 当一个线程调用一个共享变量的wait（）方法时，该调用线程会被阻塞挂起（进入waiting状态），直到发生下面几件事情之一才能返回： 其他线程调用了该共享对象的notify（）或者notifyAll（）方法； 其他线程调用了该线程的interrupt（）方法，该线程抛出InterruptedException异常返回。 另外需要注意的是，如果调用wait（）方法的线程没有事先获取该对象的监视器锁，则调用w...
手写生产者/消费者模式（三种方式）
qq_40480780的博客
01-02 1675
1.生产者/消费者模式介绍 这种模式满足三点要求： （1）生产者生产数据到缓冲区中，消费者从缓冲区中取数据。 （2）缓冲区满时，生产者线程阻塞。 （3）缓冲区空时，消费者线程阻塞。 模式组成： 公共的缓存队列（给予缓存上限）+ 生产者线程 + 消费者线程。 特点： 1.实现了生产者、消费者的解耦。 2.第一种方式，通过等待唤醒机制wait、notify/notifyAll + synchronized实现 阻塞队列 public class MyBlockingQueue { private int ma
java 之 手写 生产者-消费者
loki的博客
09-24 326
主要考点： 数据结构：消息队列； 多线程生产，多线程消费； import java.util.concurrent.*; import java.util.concurrent.atomic.AtomicInteger; /** * class ConsumerAndProducer * * @author lonkin cre...
C++面试：手写实现生产者消费者模型
weixin_42869227的博客
04-22 1302
#include<bits/stdc++.h> using namespace std; template<typename T> class Queue { public: Queue(int maxn = 50):maxnsize(maxn){} //生产者 bool Push(const T& elm) { unique_lock<mutex> ulk(_mtx); if(_qu
生产者消费者模式
12-22
生产者消费者synchronized实现方式
知识梳理：数据结构和算法、leetcode解题记录、手写生产者-消费者模型
01-15
知识梳理：数据结构和算法、leetcode解题记录、手写生产者-消费者模型、SpringAOP、Springboot 自定义注解，全局异常处理、整合 Mybatis、整合Redis、mybatis逆向工程、死锁、同步锁、读-写同步锁、BIO、NIO、AIO、...
知识梳理：数据结构和算法、leetcode解题记录、手写生产者-消费者模型、SpringAOP、Sp_practice.zip
最新发布
09-29
知识梳理：数据结构和算法、leetcode解题记录、手写生产者-消费者模型、SpringAOP、Sp_practice
手写生产者—消费者模式
pengbo6665631的博客
01-23 504
生产者—消费者模式是一个很好的并发的问题 先说几个基础的点： wait(), notify(), notifyAll()都是Object的函数 notify()仅仅通知一个线程，并且不知道通知哪一个线程，而notifyAll()会通知所有等待中的线程 在多线程共享的那个Object中使用wait()，在生产者消费者问题中，这个共享的Object就是共享缓冲区 在多线程共享的那个Objec...
手写生产者/消费者模式
suncat的博客
05-02 459
生产者/消费者 生产者持续生产，直到缓冲区满，阻塞；缓冲区不满后，继续生产 消费者持续消费，直到缓冲区空，阻塞；缓冲区不空后，继续消费 生产者可以有多个，消费者也可以有多个 生产者和消费者，共用一个BlockingQueue。为什么BlockingQueue能够实现生产者-消费者模型呢？对于put和take两个操作 ...
面试手写生产者和消费者（四种写法Synchronized、SynchronizedQueue、lock+Condition、BlockingQueue）
jike11231的博客
01-18 1628
生产者消费者方式 生产者生产产品，消费者消费， 有产品可以消费，无则不可以要生产， 生产一个消费一个。 最好烂熟于心，能手写能讲原理，因为面试手写概率比较大，了解第三种将是面试的王牌，毕竟它涉及到了CAS,volite和BlockQueue的知识，将提高的价值！ 方式一：最经典的synchronized版本 package com.ProCon; public class ProConTest1 { //这一种只需要在生产和消费方法加上sychronized锁就好了，然后生产完即通知消费即可，如果num
【复习笔记】手写生产者消费者 & 死锁
我是大菜B
09-05 1532
看到几次有面经谈到死锁跟生产消费者模型的手写代码了，手动撸一份复习一下： 生产者消费者： import java.util.ArrayList; public class proAndCus { public static void main(String[] args) { final box bigbox = new box(); for (int i = 0; i < 50
IDEA报错：import sun.misc.BASE64Decoder
qq_40301475的博客
04-24 6743
IDEA报错：import sun.misc.BASE64Decoder无法找到 Cannot resolve symbol ‘BASE64Decoder’ 这是由于JDK从1.8升级到9.0.1后sun.misc.BASE64Decoder和sun.misc.BASE64Encoder不可用，所以有两种解决方法： 更换jdk版本 手动导入jar包 这里演示第二种方法 首先下载BASE64Decoder.jar 链接：点击下载 提取码：zymy 将其保存到自己指定的位置 选择你报错的项目右键–&gt
java手写生产者和消费者模式
04-07
可以的，生产者和消费者模式是一种常见的多线程编程模式，可以通过使用锁和条件变量来实现线程间的同步和互斥。在Java中，可以使用synchronized关键字和wait/notify方法来实现生产者和消费者模式。生产者线程负责...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

晒太阳的黑宝

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值