生产者和消费者及8锁现象

最新推荐文章于 2023-08-20 16:34:30 发布
最新推荐文章于 2023-08-20 16:34:30 发布
阅读量299 收藏 1
点赞数
分类专栏： java  基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39436556/article/details/117717043
版权

JUC生产者和消费者

  1. 通过Lock 找到Condition
    在这里插入图片描述
    在这里插入图片描述
    代码实现下：
package com;

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) {
        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.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "D").start();
    }


}

// 判断等待，业务，通知
class Data2 { //数字 资源类

    private int number = 0;

    Lock lock = new ReentrantLock();

    Condition condition = lock.newCondition();

//         condition.await();//等待
//        condition.signalAll(); //唤醒全部


    //+1
    public synchronized void increment() throws InterruptedException {
        lock.lock();
        try {
            while (number != 0) {
                //等待操作
                condition.await();
              //  System.out.println(Thread.currentThread().getName() + "wait=>" + number);
                // this.wait();
            }
            number++;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            //通知其他线程，我+1 完毕了
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //-1
    public synchronized void decrement() throws InterruptedException {

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

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

Condition 精准的通知和唤醒线程
在这里插入图片描述
代码测试:

package com;


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

/**
 *
 * A 执行完调用B,B 执行完调用C ,C执行完调用A
 */
public class C {


    public static void main(String[] args) {
        Data4 data4 = new Data4();
        new Thread(() -> { for (int i = 0; i < 10; i++) data4.printA();}, "A").start();
        new Thread(() -> { for (int i = 0; i < 10; i++) data4.printB();}, "B").start();
        new Thread(() -> { for (int i = 0; i < 10; i++) data4.printC();}, "C").start();

    }
}

class Data4{ //资源类 Lock

        private Lock lock = new ReentrantLock();

        //同步监视器，通过监视器唤醒哪一个
        private  Condition condition1 = lock.newCondition();
        private  Condition condition2 = lock.newCondition();
        private  Condition condition3 = lock.newCondition();

        private int number =1; //1A 2B 3C

            public void printA(){
                lock.lock();
                try {
                     //业务，判断是否等待过程-> 执行->通知
                    while(number!=1){
                        //等待
                        condition1.await();
                    }
                    System.out.println(Thread.currentThread().getName()+"=>AAAAAAAAAAA");
                    //唤醒，唤醒指定的人B
                    number =2;
                    condition2.signal();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.lock();
                }

            }

            public void printB(){
                lock.lock();
                try {
                    //业务，判断是否等待过程-> 执行->通知
                    while (number != 2){
                        condition2.await();
                    }
                    System.out.println(Thread.currentThread().getName()+"=>BBBBBBBBBBB");
                    number=3;
                    condition3.signal();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }

            public void printC(){
                lock.lock();
                try {
                    //业务，判断是否等待过程-> 执行->通知
                    while(number!=3){
                        condition3.await();
                    }
                    System.out.println(Thread.currentThread().getName()+"=>CCCCCCCCCCCCC");
                    number =1;
                    condition1.signal();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
           //生产线: 下单->支付->交易->物流 
}

输出结果:
A=>AAAAAAAAAAA
B=>BBBBBBBBBBB
C=>CCCCCCCCCCCCC
A=>AAAAAAAAAAA
B=>BBBBBBBBBBB
C=>CCCCCCCCCCCCC
A=>AAAAAAAAAAA
B=>BBBBBBBBBBB
C=>CCCCCCCCCCCCC
A=>AAAAAAAAAAA
B=>BBBBBBBBBBB
C=>CCCCCCCCCCCCC
A=>AAAAAAAAAAA
B=>BBBBBBBBBBB
C=>CCCCCCCCCCCCC
A=>AAAAAAAAAAA
B=>BBBBBBBBBBB
C=>CCCCCCCCCCCCC
A=>AAAAAAAAAAA
B=>BBBBBBBBBBB
C=>CCCCCCCCCCCCC
A=>AAAAAAAAAAA
B=>BBBBBBBBBBB
C=>CCCCCCCCCCCCC
A=>AAAAAAAAAAA
B=>BBBBBBBBBBB
C=>CCCCCCCCCCCCC
A=>AAAAAAAAAAA

5. 8 锁现象

.如何判断锁的是谁！永远的知道什么锁，锁到底锁的是谁！
锁的是对象和 Class 模板

深刻理解我们的锁

package com.lock8;


import java.util.concurrent.TimeUnit;

/**
 * 8锁，就是关于锁的8个问题
 * 1.标准情况下，两个线程先打印，发短信还是 打电话？  1/发短信  2/打电话
 *
 *
 */
public class Test1 {


    public static void main(String[] args) {
        Phone phone = new Phone();

        //phone.sendSms; 不能回答sendSms 是先调用，锁的问题
        new Thread(()->{ phone.sendSms(); },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{ phone.call(); },"B").start();
    }
}

class Phone{

    //synchronized 锁的对象是方法的调用者！
    //两个方法用的是同一个锁，谁先拿到谁执行！
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call(){
        System.out.println("打电话");
    }


}

输出结果：
发短信
打电话

package com.lock8;

import java.util.concurrent.TimeUnit;


/**
 * 3.增加了一个普通方法后！先执行发短信还是Hello,普通方法
 * 4.两个对象，两个同步方法，发短信还是打电话？  打电话，打短信
 */
public class Test2 {

    public static void main(String[] args) {
        //两个对象,两个调用者，两把锁
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();


        //phone.sendSms; 不能回答sendSms 是先调用，锁的问题
        new Thread(()->{ phone1.sendSms(); },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
      //  new Thread(()->{ phone.call(); },"B").start();



        new Thread(()->{phone2.call();},"B").start();
    }



}

class Phone2{

    //synchronized 锁的对象是方法的调用者！
    //两个方法用的是同一个锁，谁先拿到谁执行！
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call(){
        System.out.println("打电话");
    }
    //这里没有锁！不是同步方法,不收锁的影响
    public void hello(){
        System.out.println("hello");
    }


}

输出结果：打电话，发短信

都是静态方法了，测试一下

package com.lock8;


import java.util.concurrent.TimeUnit;

/**
 * 5.增加两个静态的同步方法,只有一个对象，先答应 发短信？打电话？ 先发短信
 *
 */
public class Test3 {

    public static void main(String[] args) {
        //两个对象class 类模板只有一个，static,锁的是Class
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();


        //phone.sendSms; 不能回答sendSms 是先调用，锁的问题
        new Thread(()->{ phone1.sendSms(); },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //  new Thread(()->{ phone.call(); },"B").start();



        new Thread(()->{phone2.call();},"B").start();
    }



}
// Phone3 只有唯一的一个class 对象
class Phone3 {

    //synchronized 锁的对象是方法的调用者！
    //static 静态方法
    //类一加载就有了！锁的是 Class 模板
    public  static synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");

    }

    public static synchronized void call() {
        System.out.println("打电话");
    }

    //这里没有锁！不是同步方法,不收锁的影响
    public void hello() {
        System.out.println("hello");

    }
}

输出结果：发短信，打电话

如果是一个静态同步，一个同步那个先执行

package com.lock8;

import java.util.concurrent.TimeUnit;

/**
 *1.一个静态同步方法，1个普通同步方法，一个对象，先打印发短信?还是打电话
 *
 * 两个方法用的不是同一个锁，所以不需要等待
 *
 * 打电话，发短信
 *
 * 1.一个静态同步方法，1个普通同步方法，两个对象，先打印发短信?还是打电话
 * 
 *打电话，发短信
 *
 */
public class Test4 {



    public static void main(String[] args) {
        //两个对象class 类模板只有一个，static,锁的是Class
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();


        //phone.sendSms; 不能回答sendSms 是先调用，锁的问题
        new Thread(()->{ phone1.sendSms(); },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //  new Thread(()->{ phone.call(); },"B").start();



        new Thread(()->{phone2.call();},"B").start();
    }



}
// Phone3 只有唯一的一个class 对象
class Phone4 {

    //synchronized 锁的对象是方法的调用者！
    //static 静态同步方法
    //类一加载就有了！锁的是 Class 模板
    public  static synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");

    }

    //普通的同步方法，锁的是调用者
    public  synchronized void call() {
        System.out.println("打电话");
    }

    //这里没有锁！不是同步方法,不收锁的影响
    public void hello() {
        System.out.println("hello");

    }
}

输出结果：打电话，发短信

小结
一个new 出来的 this 具体的一个手机
一个static 锁的是Class 唯一的一个模板

偶像java练习生
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
生产者和消费者(linux)
duchenlong的博客
04-12 1076
生产者和消费者同步条件变量条件变量的接口简单实现一个生产者和一个消费者的模型 同步 同步保证了每个执行流可以合理的访问每个临界资源 同步的作用 当存在临界资源的时候，就直接获取临界资源；没有资源的时候，进行线程等待，等待其他线程让出临界资源，然后再通知等待线程。 等待线程之间再进行抢占式执行。 条件变量 当一个线程互斥的访问一个变量的时候，可能会出现在其他线程改变状态之前，他自己只能进行等待状...
Linux线程编程之生产者消费者问题
12-14
总的来说，Linux线程编程中的生产者消费者问题需要理解和掌握线程同步的基本原理和工具，如互斥锁和条件变量。通过合理的同步机制，可以构建高效、安全的多线程程序，实现生产者和消费者之间的协同工作。
使用三个锁解决生产者消费者问题
蒙牛真好的博客
12-22 334
//队列 public class Buffer { private Queue<String> queue; private int size = 10; // 消费者锁 private Object getLock = new Object(); // 生产者锁 private Object addLock = new Object(); private AtomicInteger count = new AtomicIntege
java并发编程（8）-- 线程 阻塞队列 生产者消费者 lock synchronized
软件工程小施同学 的专栏
02-08 390
一、阻塞队列概述 1. 概念： 在多线程领域：所谓阻塞，在某些情况下会挂起线程（即阻塞），⼀旦条件满⾜，被挂起的线程⼜ 会⾃动被唤醒。 阻塞队列 是⼀个队列，在数据结构中起的作⽤如下图： 当队列是空的，从队列中获取（Take）元素的操作将会被阻塞 当队列是满的，从队列中添加（Put）元素的操作将会被阻塞 试图中空的队列中获取元素的线程将会被阻塞，直到其他线程往空的队列插⼊新的元素 试图向已满的队列中添加新元素的线程将会被阻塞，直到其他线程从队列中移除⼀个或多个元素 或者完全清空，.
面试官看了都说好的Synchronized详解
qq_46993700的博客
06-16 3477
互斥同步 Java 提供了两种锁机制来控制多个线程对共享资源的互斥访问，第一个是 JVM 实现的 synchronized，而另一个是 JDK 实现的 ReentrantLock。 synchronized 1. 同步一个代码块 public void func() { synchronized (this) { // ... } } 它只作用于同一个对象，如果调用两个对象上的同步代码块，就不会进行同步。 对于以下代码，使用 ExecutorService 执行了两个线程，
＜ Linux ＞ 多线程（生产者消费者模型）
bit_zyx的博客
03-13 1355
目录 1、生产者消费者模型 生产者消费者模型的例子 生产者消费者模型的特点 生产者消费者模型的优点 2、基于BlockingQueue的生产者消费者模型 概念 模拟实现基于阻塞队列的生产消费模型 基于计算任务的生产者消费者模型（并发）
Linux多线程——生产者消费者模型
weixin_57023347的博客
09-24 3790
一.生产者消费者模型 1.1 什么是生成者消费者模型 一个进程中的线程有两种角色，一种是生产者，一种是消费者。生产者为消费者提供任务，消费者拿到任务，解决任务。在生成者和消费者之间还有一个"交易场所"，是一个内存块。生成者线程将任务放到内存块中，消费者线程在内存块中拿任务。当内存块数据达到一高水位线时，生产者会进行等待，唤醒消费者拿任务，当内存块数据达到一低水位线时，消费者会等待，并且唤醒生产者生产任务。 生成者，消费者存在着3种关系。生产者和生产者之间......
Java多线程——生产者消费者问题
泯灭于众生，高歌于孤夜！
01-19 6028
创建多个线程去执行不同的任务，如果这些任务之间有着某种关系，那么线程之间必须能够通信来协调完成工作。 生产者消费者问题（英语：Producer-consumer problem）就是典型的多线程同步案例，它也被称为有限缓冲问题（英语：Bounded-buffer problem）。该问题描述了共享固定大小缓冲区的两个线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保
Linux 生产者和消费者问题
最新发布
NuYoaH502329的博客
08-20 758
由结果可以看出，并不是每个线程每次输出的都是5000，而是会有低于5000的情况，这是因为可能会有两个线程在并行运行的时候同时去访问变量g_count，两个线程拿到的g_count的值是相同的，同时执行g_count++，这样就会导致两个线程并不会把g_count的值分别加两次，属于两个线程同时对g_count加1，相当于g_count只加了一次，就会使我们少一个数字。第二个参数pshared：控制信号量的类型，如果其值为0，就表示整个信号量是当前进程的局部信号量，不让该信号量在多个进程之间共享。
生产者消费问题以及多生产者—消费者问题实现思想
派拉斯兔子的博客
08-23 5029
一、生产者消费问题 系统中有一组生产者进程和一组消费者进程，生产者进程每次生产一个产品放入缓冲区，消费者 进程每次从缓冲区中取出一个产品并使用。（注：这里的“产品”理解为某种数据） 生产者、消费者共享一个初始为空、大小为n的缓冲区。 只有 缓冲区没满 时，生产者才能把产品放入缓冲区，否则必须等待。 【缓冲区没满→生产者生产】 只有 缓冲区不空 时，消费者才能从中取出产品，否则必须等待。 【缓冲区没空→消费者消费】 缓冲区是临界资源，各进程必须互斥地访问。 PV操作题目分析步骤： ①、关系分析。
消息队列：生产者/消费者模式
热门推荐
qq_39575279的博客
02-28 2万+
1.什么是生产者消费者模式 生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。 这个阻塞队列就是用来给生产者和消费者解耦的。...
Java多线程生产者消费者模式实现过程解析
08-19
Java多线程生产者消费者模式是指在Java编程中，使用多线程来实现生产者和消费者之间的数据交换 и处理的模式。该模式下，生产者负责产生数据，而消费者负责处理数据。这种模式可以提高系统的性能和效率，特别是在高...
架构设计 -- 生产者/消费者模式
08-26
【生产者/消费者模式】是一种常见的并发编程和系统设计模式，它主要解决的是在多线程环境下，如何协调生产者和消费者之间的数据处理问题。在软件开发中，生产者通常是生成数据的一方，而消费者则是处理这些数据的...
生产者-消费者多线程处理
07-11
生产者-消费者模型涉及到两个主要角色：生产者（Producer）和消费者（Consumer）。生产者负责生成数据或产品，并将其放入一个共享的缓冲区；而消费者则从这个缓冲区中取出并消费这些数据或产品。在我们的例子中，有...
consumer_producer.rar_操作系统_生产 消费_生产者－消费者问题_进程调度
09-22
在操作系统领域，生产者-消费者问题是多线程和进程同步的经典模型，用于描述并发执行的生产者进程与消费者进程如何共享资源而不会产生数据竞争或死锁的现象。在这个问题中，生产者负责生成数据，而消费者则负责消费...
ForkJion
weixin_39436556的博客
06-14 9386
ForkJoin 什么是ForkJoin ForkJion 在JDK1.7,并行执行任务！提高效率。大数据量！ 大数据：Map Reduce(将大任务拆分为小任务) ForkJion 特点：工作窃取 这个里面维护的都是双端队列，A 线程没有执行完，B线程执行完了，B 线程则去 执行A 中的（红框）未执行完任务 ForkJion 代码案例： package com.forkjoin; import java.util.concurrent.ExecutionException; imp
java四大函数式接口（重点，简单）
weixin_39436556的博客
06-14 2351
四大函数式接口 新时代的程序员：lambda 表达式，链式编程，函数式接口，Stream 流式计算 函数式接口： 只有一个方法的接口 @FunctionalInterface public interface Runnable { public abstract void run(); } //超级多FunctionalInterface //简化编程模型，在新版本的框架底层大量应用! //foreach(消费者类型的函数式接口) 代码测试: Function 函数式接口 pack
java_异步回调
weixin_39436556的博客
06-15 2203
异步回调 Future 设计的初衷：对将来的某个时间的结果进行建模 代码示例 package com.future; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException; import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; /** * * 异步调用:Ajax *
java_父类
weixin_39436556的博客
05-18 1295
继承 子类构造器中默认调用父类构造器 super(); 重写 需要有继承关系，子类重写父类的方法 方法名必须相同 参数列表必须相同 修饰符，范围可以扩大： public ->Protected>defaule ->private 抛出的异常：范围，可以被缩小，但不能扩大：ClassNotFoundException --> Exception(大) 重写,子类的方法和父类必要一致；方法体不同！ 为什么需要重写： 1.父类的功能，子类不一定需要，或者不一定满足! 代码如下：
python生产者与消费者进程不会停下来
05-27
生产者和消费者进程不会停止的原因可能是由于没有正确地设置同步机制，导致进程出现了阻塞或死锁现象。可以使用线程队列或锁等同步机制来解决这个问题。在生产者进程中，当队列已满时，可以使用条件变量阻塞该进程，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值