如何用synchronized和lock锁实现生产者和消费者模式

最新推荐文章于 2022-10-17 22:09:41 发布
最新推荐文章于 2022-10-17 22:09:41 发布
阅读量136 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53917137/article/details/114409927
版权

1.synchronized

2.Lock锁

涉足刻印
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Lock、Condition实现简单的生产者消费者模式示例
09-04
这个示例展示了如何使用`Lock`和`Condition`来实现生产者消费者模式的基本逻辑。`Lock`接口相比`synchronized`关键字的优势在于它可以更灵活地控制锁的获取和释放，以及条件的等待和唤醒。此外，`Condition`接口可以...
Java多种方式实现生产者消费者模式
08-18
Java中实现生产者消费者模式有多种方式，下面将详细介绍两种方式：使用synchronized和Object的wait和notifyAll方法，使用jdk1.8的Lock和Condition。 方式一：使用synchronized和Object的wait和notifyAll方法 在...
JUC - 多线程之Synchronized和Lock锁；生产者消费者模式（一）
MinggeQingchun的博客
10-17 570
JUC首先，再简单说一下并行、并发；进程、线程。
Java多线程与并发_Synchronized和Lock实现生产者消费者模式
shugeshow's Blog
04-24 361
Java多线程与并发_Synchronized和Lock实现生产者消费者 能自己扛，就别声张​ 一、生产者消费者例子 现在两个线程 可以操作初始值为零的一个变量， 实现一个线程对该变量加1，一个线程对该变量减1 交替，来10轮，变量初始值为零 二、Synchronized实现 /** * @Author: slx * @Date: 2019/4/24 19:09 */ public clas...
JAVA多线程（五）用lock、synchronized、阻塞队列三种方法实现生产者消费者模式
橙子wj的博客
05-25 6694
用乐观锁、悲观锁、阻塞队列三种方法实现生产者消费者模式
Lock和syncronized
weixin_40695328的博客
01-22 305
ReentrantLock是可重入锁(获取多少次锁就要释放多少锁) 公平/非公平都可以 synchronized 可重入 非公平： 配合常量池中的ACC_SYNCHRONIZED标识位 通过竞争监视器或者说管程monitor(两个原语monitorenter monitorexit 同一个时刻，只有一个 进程/线程能进入monitor中定义的临界区——》 monitor 能够达到互斥的效果)来实...
实现生产者消费者模式的四种方式（Synchronized、Lock、BlockingQueue、Semaphore）
mengqingming1的博客
11-18 580
一、问题描述 生产者消费者问题（Producer-consumer problem），也称有限缓冲问题（Bounded-buffer problem），是一个多线程同步问题的经典案例。生产者生成一定量的数据放到缓冲区中，然后重复此过程；与此同时，消费者也在缓冲区消耗这些数据。生产者和消费者之间必须保持同步，要保证生产者不会在缓冲区满时放入数据，消费者也不会在缓冲区空时消耗数据。不够完善的解决方法...
Java基于Lock的生产者消费者模型示例
08-27
本示例中，我们使用了Lock和Condition来实现生产者消费者模型，避免了使用synchronized关键字的方式，而是使用了Lock和Condition来实现线程同步和通信，提高了程序的性能和可读性。 知识点： * Java中的生产者消费...
Java多线程生产者消费者模式实现过程解析
08-19
在Java中，实现生产者消费者模式可以使用Thread类和synchronized关键字来实现线程之间的同步和通信。 在示例代码中，我们可以看到，生产者与消费者之间的数据交换是通过共享的锁对象来实现的。生产者将数据放入共享...
java生产者消费者问题代码实现
最新发布
12-25
我们将使用多线程编程技术来模拟生产者和消费者之间的关系，并使用 synchronized 关键字来实现线程同步。 首先，我们需要定义一个缓冲区来存放生产者的数据。在这个缓冲区中，我们可以存放 20 个整型数，编号从 1 ...
使用synchronized关键字与ReentrantLock实现生产者-消费者
weixin_43905219的博客
03-31 130
生产者-消费者使用synchronized关键字实现使用ReentrantLock和Condition实现 两种实现方式都大同小异，关键在于生产与消费的动作上，一边是synchronized加锁，Object.wait()与Object.notifyAll()实现等待与唤醒，而另一边是ReentrantLock加锁，Condition实现等待与唤醒 废话不多说，直接上代码，注意使用while代替i...
使用Lock来实现生产者和消费者问题
Java 之 道
08-22 3126
Lock的await/singal 和 Object的wait/notify 的区别 在使用Lock之前，我们都使用Object 的wait和notify实现同步的。举例来说，一个producer和consumer，consumer发现没有东西了，等待，produer生成东西了，唤醒。 线程consumer 线程producer synchronize(obj){
ReentrantLock的介绍使用及“生产者消费者”模式实现
阿飞的博客
07-02 1459
一、简介 ReentrantLock 即可重入锁的意思，是 java 控制线程同步的一种方式。和 synchronized 一样都是独占锁，只允许拿到锁的线程访问临界区。 synchronized 优点是使用简单，不需要用户手动操作，加锁解锁的过程都是隐式的。 ReentrantLock 则需要我们手动加锁和解锁（解锁操作通常放在 finally 代码块中保证执行），虽然使用更复杂但是其灵活性更好...
synchronized和ReentrantLock，实现生产消费模式
Always`的博客
03-09 190
1.介绍 生产消费模式实质上考察的是，多线程情况下的 等待唤醒机制 ，文中用 synchronized 和 ReentrantLock 分别进行实现。 2.具体实现 1.描述 生产者：生产者向容器(lists)中put数据，直到容器到达指定容量，生产者将会等待,并唤醒消费者。 消费者：消费者向容器(lists)中get数据，直到容器容量为空，消费者将会等待，并唤醒生产者。 2.接口 public interface ProCon<T> { /** * 生产 *
Java并行编程-lock中使用多条件condition（生产者消费者模式实例）
热门推荐
记忆力不好的博客
06-05 2万+
Java 并发包下的提供Lock，Lock相对于Synchronized可以更好的解决线程同步问题，更加的灵活和高效，并且ReadWriteLock锁还能实现读、写的分离。但线程间仅仅互斥是不够的，还需要通信，本篇的内容是基于上篇之上，使用Lock如何处理线程通信。阻塞队列(BlockingQueue)就是使用condition的和lock实现的。可以查看：Java并发编程-阻塞队列(Blockin
用synchronized或ReentrantLock实现的消费者与生产者
chy_want的博客
08-22 324
以如下场景为案例： 假设某公司有一个仓库，该仓库只能容下3件货物。 该公司有4名员工，分别为2名进货员（生产者）与2名销售员（消费者）。 每名进货员每次只能进一件货物，每名销售员每次只能卖出一件货物。 以synchronized实现： public class SynTest { public static void main(String[] args) { Clerk clerk = new Clerk(); new Thread(() -> {
Java多线程并发实例生产者消费者--加锁实现
weixin_38296425的博客
08-07 2640
在这个案例中使用可重入锁来实现生产者消费模型。 在这个案例中分别使用两个线程对同一个对象进行操作，实现生产一个商品消费一个商品的操作。 多线程操作的三个重要步骤： 1. 线程操作资源类 2. 判断、干活(业务处理)、唤醒通知 3. 严防虚假唤醒 在资源类UserShareData中义了两个方法 producer() 方法用于生产一个商品 consumer()方法用于消费一个商品 在producer() 方法遵循多线程处理的3个步骤，因为使用的加锁机制，所以基本模式是这样： 加锁 try{ 1.
Java并发编程-Lock锁与生产者消费者问题
Java硬件工程师的博客
12-31 2847
传统Synchronized锁 实现一个基本的售票例子： /* 真正的多线程开发，公司中的开发,降低耦合性 线程就是一个单独的资源类，没有任何附属的操作 1.属性，方法 * */ public class SaleTicketDemo1 { public static void main(String[] args) { //并发，多个线程操作同一个资源类,把资源类丢入线程 Ticket ticket=new Ticket(); //Runnable
java实现生产者和消费者问题的几种方式
xiaoddt的博客
06-05 355
java实现生产者和消费者问题的几种方式
Java：分别利用 synchronized、Lock和阻塞队列的方法模拟生产者-消费者的同步问题。 分别利用 synchronized、Lock和阻塞队列的方法实现交替输出ABABABAB。
06-08
生产者-消费者同步问题的模拟： 使用synchronized： ```java public class ProducerConsumer { private static final int BUFFER_SIZE = 10; private static final Object lock = new Object(); private static int[] buffer = new int[BUFFER_SIZE]; private static int count = 0; public static void main(String[] args) { Thread producer = new Thread(() -> { for (int i = 0; i < BUFFER_SIZE; i++) { synchronized (lock) { while (count == BUFFER_SIZE) { try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } buffer[count++] = i; lock.notifyAll(); } } }); Thread consumer = new Thread(() -> { for (int i = 0; i < BUFFER_SIZE; i++) { synchronized (lock) { while (count == 0) { try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println(buffer[--count]); lock.notifyAll(); } } }); producer.start(); consumer.start(); } } ``` 使用Lock： ```java public class ProducerConsumer { private static final int BUFFER_SIZE = 10; private static final Lock lock = new ReentrantLock(); private static final Condition notFull = lock.newCondition(); private static final Condition notEmpty = lock.newCondition(); private static int[] buffer = new int[BUFFER_SIZE]; private static int count = 0; public static void main(String[] args) { Thread producer = new Thread(() -> { for (int i = 0; i < BUFFER_SIZE; i++) { lock.lock(); try { while (count == BUFFER_SIZE) { notFull.await(); } buffer[count++] = i; notEmpty.signalAll(); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); } } }); Thread consumer = new Thread(() -> { for (int i = 0; i < BUFFER_SIZE; i++) { lock.lock(); try { while (count == 0) { notEmpty.await(); } System.out.println(buffer[--count]); notFull.signalAll(); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); } } }); producer.start(); consumer.start(); } } ``` 使用阻塞队列： ```java public class ProducerConsumer { private static final int BUFFER_SIZE = 10; public static void main(String[] args) { BlockingQueue<Integer> buffer = new ArrayBlockingQueue<>(BUFFER_SIZE); Thread producer = new Thread(() -> { for (int i = 0; i < BUFFER_SIZE; i++) { try { buffer.put(i); } catch (InterruptedException e) { e.printStackTrace(); } } }); Thread consumer = new Thread(() -> { for (int i = 0; i < BUFFER_SIZE; i++) { try { System.out.println(buffer.take()); } catch (InterruptedException e) { e.printStackTrace(); } } }); producer.start(); consumer.start(); } } ``` 交替输出ABABABAB的实现： 使用synchronized： ```java public class AlternatePrinting { private static final Object lock = new Object(); private static boolean flag = true; public static void main(String[] args) { Thread t1 = new Thread(() -> { for (int i = 0; i < 5; i++) { synchronized (lock) { while (!flag) { try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.print("A"); flag = false; lock.notifyAll(); } } }); Thread t2 = new Thread(() -> { for (int i = 0; i < 5; i++) { synchronized (lock) { while (flag) { try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.print("B"); flag = true; lock.notifyAll(); } } }); t1.start(); t2.start(); } } ``` 使用Lock： ```java public class AlternatePrinting { private static final Lock lock = new ReentrantLock(); private static final Condition condition = lock.newCondition(); private static boolean flag = true; public static void main(String[] args) { Thread t1 = new Thread(() -> { for (int i = 0; i < 5; i++) { lock.lock(); try { while (!flag) { condition.await(); } System.out.print("A"); flag = false; condition.signalAll(); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); } } }); Thread t2 = new Thread(() -> { for (int i = 0; i < 5; i++) { lock.lock(); try { while (flag) { condition.await(); } System.out.print("B"); flag = true; condition.signalAll(); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); } } }); t1.start(); t2.start(); } } ``` 使用Semaphore： ```java public class AlternatePrinting { private static final Semaphore s1 = new Semaphore(1); private static final Semaphore s2 = new Semaphore(0); public static void main(String[] args) { Thread t1 = new Thread(() -> { for (int i = 0; i < 5; i++) { try { s1.acquire(); System.out.print("A"); s2.release(); } catch (InterruptedException e) { e.printStackTrace(); } } }); Thread t2 = new Thread(() -> { for (int i = 0; i < 5; i++) { try { s2.acquire(); System.out.print("B"); s1.release(); } catch (InterruptedException e) { e.printStackTrace(); } } }); t1.start(); t2.start(); } } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值