JAVA-多线程-生产者与消费者

最新推荐文章于 2024-02-03 11:46:49 发布
最新推荐文章于 2024-02-03 11:46:49 发布
阅读量219 收藏
点赞数
分类专栏： 学习 线程 笔记 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43421142/article/details/108279849
版权
笔记 同时被 3 个专栏收录
109 篇文章 0 订阅
订阅专栏
学习
104 篇文章 0 订阅
订阅专栏
线程
3 篇文章 0 订阅
订阅专栏
本文详细介绍了Java多线程环境下实现生产者消费者模式的四种方法，包括使用wait()与notify()、await()与signalAll()、Lock与Condition机制以及BlockingQueue阻塞队列，每种方法均有详细的代码示例。
摘要由CSDN通过智能技术生成

JAVA-多线程-生产者与消费者

介绍

生产者与消费者问题是多线程同步的一个经典问题。生产者和消费者同时使用一块缓冲区，生产者生产商品放入缓冲区，消费者从缓冲区中取出商品。我们需要保证的是，当缓冲区满时，生产者不可生产商品；当缓冲区为空时，消费者不可取出商品。

方法实现

方法一 wait()与notify()方法

wait()用在以下场合:
（1）当缓冲区满时，缓冲区调用wait()方法，使得生产者释放锁，当前线程阻塞，其他线程可以获得锁。
（2）当缓冲区空时，缓冲区调用wait()方法，使得消费者释放锁，当前线程阻塞，其他线程可以获得锁。
notify()用在以下场合：
（1）当缓冲区未满时，生产者生产商品放入缓冲区，然后缓冲区调用notify()方法，通知上一个因wait()方法释放锁的线程现在可以去获得锁了，同步块代码执行完成后，释放对象锁，此处的对象锁，锁住的是缓冲区。
（2）当缓冲区不为空时，消费者从缓冲区中取出商品，然后缓冲区调用notify()方法，通知上一个因wait()方法释放锁的线程现在可以去获得锁了，同步块代码执行完成后，释放对象锁。

代码实现
import java.util.LinkedList;

class ShareData1 {

	// 最大容量
	public static final int MAX_SIZE = 4;
	// 存储媒介
	public static LinkedList<Integer> list = new LinkedList<>();

	// 生产者
	public void product() {
		synchronized (list) {
			while (list.size() == MAX_SIZE) {
				System.out.println("缓冲区已满，停止生产！");
				try {
					list.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			list.add(1);
			System.out.println("生产者 " + Thread.currentThread().getName() + " 生产, 缓冲区容量为 " + list.size());
			list.notify();
		}
	}

	// 消费者
	public void customer() {
		synchronized (list) {
			while (list.size() == 0) {
				System.out.println("缓冲区已为空，停止消费！");
				try {
					list.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			list.removeFirst();
			System.out.println("消费者 " + Thread.currentThread().getName() + " 消费，缓冲区容量为 " + list.size());
			list.notify();
		}
	}
}

public class ProductAndCustomer {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ShareData1 shareData = new ShareData1();

		new Thread(() -> {
			for (int i = 0; i < 5; i++) {
				try {
					shareData.product();
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}, "AAA").start();
		
		new Thread(() -> {
			for (int i = 0; i < 5; i++) {
				try {
					shareData.customer();
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}, "BBB").start();

	}

}
输出

输出

方法二 await()与signalAll()

（1）await()：导致当前线程等待，直到其他线程调用该Condition的signal()或signalAll()方法唤醒该线程。

（2）signal()：唤醒在此Lock对象上等待的单个线程。

（3）signalAll()：唤醒在此Lock对象上等待的所有线程。

代码实现
import java.util.LinkedList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class ShareData2 {

	// 最大容量
	public static final int MAX_SIZE = 4;
	// 存储媒介
	public static LinkedList<Integer> list = new LinkedList<>();
	//lock
	private Lock lock = new ReentrantLock();
	//条件变量
	private Condition condition = lock.newCondition();

	// 生产者
	public void product() {
		lock.lock();
		try {
			while (list.size() == MAX_SIZE) {
				System.out.println("缓冲区已满，停止生产！");
				condition.await();
			}
			list.add(1);
			System.out.println("生产者 " + Thread.currentThread().getName() + " 生产, 缓冲区容量为 " + list.size());
			condition.signalAll();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			lock.unlock();
		}
	}

	// 消费者
	public void customer() {
		lock.lock();
		try {
			while (list.size() == 0) {
				System.out.println("缓冲区已为空，停止消费！");
				condition.await();
			}
			list.removeFirst();
			System.out.println("消费者 " + Thread.currentThread().getName() + " 消费，缓冲区容量为 " + list.size());
			condition.signalAll();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			lock.unlock();
		}
	}
}

public class ProductAndCustomer2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ShareData2 shareData = new ShareData2();

		new Thread(() -> {
			for (int i = 0; i < 5; i++) {
				try {
					shareData.product();
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}, "AAA").start();

		new Thread(() -> {
			for (int i = 0; i < 5; i++) {
				try {
					shareData.customer();
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}, "BBB").start();

	}

}
输出

在这里插入图片描述

方法三 Lock与Condition机制

Condition接口的await()和signal()是用来做同步的两种方法，它们的功能基本上和Object的wait()、nofity()相同，或者说可以取代它们，但是它们和Lock机制是直接挂钩的。通过在Lock对象上调用newCondition()方法，将条件变量和一个锁对象进行绑定，进而控制并发程序访问竞争资源的安全。

代码实现
import java.util.LinkedList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class ShareData3 {

	// 最大容量
	public static final int MAX_SIZE = 4;
	// 存储媒介
	public static LinkedList<Integer> list = new LinkedList<>();
	// lock
	public static Lock lock = new ReentrantLock();
	// 仓库满的条件变量
	public static Condition full = lock.newCondition();
	// 仓库空的条件变量
	public static Condition empty = lock.newCondition();

	// 生产者
	public void product() {
		lock.lock();
		while (list.size() == MAX_SIZE) {
			try {
				System.out.println("缓冲区已满，停止生产！");
				full.await();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		list.add(1);
		System.out.println("生产者 " + Thread.currentThread().getName() + " 生产, 缓冲区容量为 " + list.size());
		// 唤醒其他生产者与消费者线程
		full.signal();
		empty.signal();
		lock.unlock();
	}

	// 消费者
	public void customer() {
		lock.lock();
		while (list.size() == 0) {
			try {
				System.out.println("缓冲区已为空，停止消费！");
				empty.await();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		list.removeFirst();
		System.out.println("消费者 " + Thread.currentThread().getName() + " 消费，缓冲区容量为 " + list.size());
		//唤醒其他生产者与消费者线程
		full.signal();
		empty.signal();
		lock.unlock();
	}
}

public class ProductAndCustomer3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ShareData3 shareData = new ShareData3();

		new Thread(() -> {
			for (int i = 0; i < 5; i++) {
				try {
					shareData.product();
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}, "AAA").start();

		new Thread(() -> {
			for (int i = 0; i < 5; i++) {
				try {
					shareData.customer();
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}, "BBB").start();

	}

}
输出

输出

方法四 BlockingQueue阻塞队列

如果向一个已经满了的队列中添加元素或者从空队列中移除元素，都将会导致线程阻塞，线程一直等待到有旧元素被移除或新元素被添加的时候，才能继续执行。符合这种情况的队列，称为阻塞队列。
put():向阻塞队列中添加一个元素，队列满时，自动阻塞。
take():从阻塞队列中取出一个元素，队列空时，自动阻塞。

代码实现
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

class ShareData4 {

	// 最大容量
	public static final int MAX_SIZE = 4;
	// 存储媒介
	public static BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(MAX_SIZE);

	// 生产者
	public void product() {
		while (queue.size() == MAX_SIZE) {
			System.out.println("缓冲区已满，停止生产！");
		}
		try {
			queue.put(1);
			System.out.println("生产者 " + Thread.currentThread().getName() + " 生产, 缓冲区容量为 " + queue.size());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	// 消费者
	public void customer() {
		while (queue.size() == 0) {
			System.out.println("缓冲区已为空，停止消费！");
			try {
				queue.take();
				System.out.println("消费者 " + Thread.currentThread().getName() + " 消费，缓冲区容量为 " + queue.size());
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

		}
	}
}

public class ProductAndCustomer4 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ShareData4 shareData = new ShareData4();

		new Thread(() -> {
			for (int i = 0; i < 5; i++) {
				try {
					shareData.product();
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}, "AAA").start();

		new Thread(() -> {
			for (int i = 0; i < 5; i++) {
				try {
					shareData.customer();
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}, "BBB").start();

	}

}
输出

在这里插入图片描述

123cw
关注
专栏目录
java多线程实现生产者和消费者
04-15
java多线程实现生产者和消费者
Java多线程：生产者-消费者模型
最新发布
子夜的个人博客
02-10 1714
生产者-消费者模型
Java线程(三)：线程协作-生产者/消费者问题
热门推荐
寻道
04-06 4万+
上一篇讲述了线程的互斥(同步)，但是在很多情况下，仅仅同步是不够的，还需要线程与线程协作(通信)，生产者/消费者问题是一个经典的线程同步以及通信的案例。该问题描述了两个共享固定大小缓冲区的线程，即所谓的“生产者”和“消费者”在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不...
Java 多线程——生产者与消费者
weixin_34380948的博客
12-11 78
2019独角兽企业重金招聘Python工程师标准>>> ...
Java多线程-生产者消费者
drizzletowne的博客
10-19 354
生产者消费者模式是一个十分经典的多线程协作的模式，生产者消费者问题主要是包含了两类线程： 生产者线程 用于生产数据 消费者线程 用于消费数据 为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库。 生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为。 消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为 下面案例用多线程模拟生产蛋糕： // 生产者生产蛋糕，将其打包装进箱子（box）, 消费者每次消费一个 public class B
Java多线程-生产者与消费者问题
02-03
### Java多线程-生产者与消费者问题 #### 一、生产者与消费者问题概览 **1.1 概要** 生产者与消费者问题是计算机科学中一个多线程同步的经典问题。它描述了两个线程如何共享有限资源的场景：一个是生产者...
JAVA多线程实现生产者消费者的实例详解
08-30
JAVA多线程实现生产者消费者的实例详解 JAVA多线程实现生产者消费者是指在JAVA编程语言中使用多线程技术来实现生产者消费者模型的实例详解。生产者消费者模型是指在计算机科学中的一种经典模式，描述了生产者和消费...
java—多线程的通信、生产者与消费者模式
12-21
理解Java多线程通信和生产者-消费者模式对于编写高效并发程序至关重要。使用`synchronized`关键字和`wait()`, `notify()`, `notifyAll()`来控制线程间的协作，可以避免数据竞争和死锁等问题。同时，掌握线程的状态和...
Java多线程生产者消费者模式实现过程解析
08-19
Java多线程生产者消费者模式实现过程解析 Java多线程生产者消费者模式是指在Java编程中，使用多线程来实现生产者和消费者之间的数据交换 и处理的模式。该模式下，生产者负责产生数据，而消费者负责处理数据。这种...
Java多线程 BlockingQueue实现生产者消费者模型详解
08-25
Java多线程BlockingQueue实现生产者消费者模型详解 Java多线程中，生产者消费者模型是非常重要的一种设计模式，它可以解决多线程之间的数据传输问题。在Java中，我们可以使用BlockingQueue来实现生产者消费者模型，...
Java多线程实现生产者消费者
05-29
编写一个“生产者-消费者”的多线程演示程序，两个生产者，一个消费者，可以存放产品的仓库容量为10，仓库用栈实现，并有同步功能，且能防止先消费后生产的情况。
Java多线程--生产者与消费者问题
人生得意须尽欢
02-03 1545
Java多线程--生产者与消费者问题
三.java多线程之线程调度
贾世鑫的博客
09-26 771
三.java多线程之线程调度 1、调整线程优先级：Java线程有优先级，优先级高的线程会获得较多的运行机会。   Java线程的优先级用整数表示，取值范围是1~10，Thread类有以下三个静态常量： static int MAX_PRIORITY           线程可以具有的最高优先级，取值为10。 static int MIN_PRIORITY
Java多线程：线程通信：生产者 和 消费者 || 顺序打印
weixin_61635597的博客
01-12 362
在Object.java中，定义了wait(), notify()和notifyAll()等方法。wait()的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。notify()和notifyAll()的作用，则是唤醒当前对象上的等待线程；notify()是唤醒单个线程，而是唤醒所有的线程。异常这 三个wait(),notify(), notifyAll()方法只有在synchronized方法或synchronized代码块中才能使用，否则会报异常如下是图示说明。
java多线程经典例题：生产者/消费者问题
zjhzxjq的博客
03-06 1998
生产者/消费者问题 题目描述： 生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。 代码： class Clerk {/...
玩转java多线程 之多线程基础 生产者消费者问题 以及 解决此类问题的方法
weixin_45806131的博客
10-10 581
有两个线程，一个生产线程，一个消费线程 应用场景： 假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者取走消费 假设没有商品，生产者将产品放入仓库，否则停止生产并等待，直到仓库中产品被消费者取走为止 如果有产品，消费者取走消费，否则停止消费等待，直到仓库中有产品为止 ...
基于JAVA的生产者消费者问题
11-30 120
在操作系统课上的一点小感想，基于JAVA的生产者消费者问题，分享出来和大家一起学习。 同步机制，首先采用Java的synchronized来实现对缓冲区的互斥访问，再设置一个信号量来实现对缓冲区为空和为满的状态标记。生产者通过在synchronized同步代码块中先对缓冲区是否为满作出判断，若缓冲区为满，将当前线程添加到缓冲区的等待列表中，线程阻塞，并且在...
Java多线程之生产者与消费者
qq_40690077的博客
08-22 275
题目： 生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产； 如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。 分析问题： 1.使用多线程：生产者和消费者 2.共享数据...
java多线程——生产者和消费者
IT界的小清流
07-13 162
使用同步方法来保证数据的一致性，使用wait() 和 notify() 、notifyAll()方法来解决重复操作。 public class Test { public static void main(String[] args) { Message msg = new Message(); Producer producer = new Prod...
Java多线程实践：消费者-生产者模型解析与优化
"Java多线程中的消费者-生产者模型是一种经典的并发编程模式，用于解决两个或多个线程之间的同步问题。在这个模型中，生产者线程负责创建数据（产品），而消费者线程则负责处理这些数据。为了保证系统的稳定和高效...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值