生产者和消费者模式

最新推荐文章于 2024-07-23 10:19:57 发布

yuan10277

最新推荐文章于 2024-07-23 10:19:57 发布

阅读量299

点赞数

分类专栏：基础知识文章标签：设计模式多线程 java

基础知识专栏收录该内容

2 篇文章 0 订阅

订阅专栏

生产者-消费者模式是一个经典的多线程设计模式，它为多线程的协作提供了良好的解决方案。在生产者-消费者模式中，通常有两类线程，即若干个生产者线程和若干个消费者线程。生产者线程负责提交用户请求，消费者线程负责处理用户请求。生产者和消费者之间通过共享内存缓冲区进行通信。

生产者-消费者模式中的内存缓冲区的主要功能是数据在多线程间的共享。此外，通过该缓冲区，可以缓解生产者和消费者之间的性能差。

Java多线程编程中，常用的多线程设计模式包括：Future模式、Master-Worker模式、Guarded Suspeionsion模式、不变模式和生产者-消费者模式等。这篇文章主要讲述不变模式，关于其他多线程设计模式的地址如下：
关于Future模式的详解： Java多线程编程中Future模式的详解
关于Master-Worker模式的详解： Java多线程编程中Master-Worker模式的详解
关于Guarded Suspeionsion模式的详解： Java多线程编程中Guarded Suspeionsion模式的详解
关于不变模式的详解： Java多线程编程中不变模式的详解

下面以生产者生产馒头、消费者吃馒头为例说明生产者-消费者模式，并用Java代码实现。

线程通信，线程之间的消息传递；

多个线程在操作同一个资源，但对共享资源的操作动作不同；它们共享同一个资源，互为条件，相互依赖,相互通信让任务向前推进。

线程的同步，可以解决并发更新同一个资源，实现线程同步;但不能用来实现线程间的消息传递。

线程通信生产者和消费者和仓库是个典型模型：

生产者：没有生产之前通知消费者等待，生产产品结束之后，马上通知消费者消费

消费者：没有消费之前通知生产者等待，消费产品结束之后，通知生产者继续生产产品以供消费

线程通信：使用Java中Object中提供的：

public final void wait(); 注：long timeout=0 表示线程一直等待，直到其它线程通知

public final native void wait(long timeout); 线程等待指定毫秒参数的时间

public final void wait(long timeout, int nanos); 线程等待指定毫秒、微妙的时间timeout最大等待时间,以毫秒为单位，nanos额外的时间,在纳秒范围0-999999。

public final native void notify(); 唤醒一个处于等待状态的线程

public final native void notifyAll(); 唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先运行

这些方法只能在同步方法或者同步代码块中使用，否则会抛出异常。

Exception in thread "Thread-0"java.lang.IllegalMonitorStateException
at java.lang.Object.wait(Native Method)
at java.lang.Object.wait(Object.java:485)
at ca.bb.ShareCached.getShareCachedData(ShareCached.java:41) //wait();

以及使用，回调方法，实现线程通信。

其中，2中的装馒头为生产者，取馒头为消费者。3，4依次为生产者线程和消费者线程

模式通过解耦生产者和消费者，来平衡两者的处理能力。

1. 馒头

这里采用了面向对象的设计思想，馒头在整个程序中自然是一个类，其Java代码如下。

[java] view plain copy

print ?

class ManTou {
int id;
ManTou(int id) {
this.id = id;
}
public String toString() {
return "ManTou: " + id;
}
}

class ManTou {
	int id;
	ManTou(int id) {
		this.id = id;
	}
	
	public String toString() {
		return "ManTou: " + id;
	}
}

2. 篮子（装馒头）

篮子是有容量的，因此篮子类需要有一个变量表示容量；篮子至少还有取和装馒头这两个功能，其Java代码如下：

[java] view plain copy

print ?

class SyncStack { //篮子
int index = 0;
ManTou[] arrMT = new ManTou[6]; //假设这个篮子只能装6个馒头
public synchronized void push(ManTou wt) { //装馒头
while(index == arrMT.length) { //篮子满了
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.notify(); //如果取馒头的wait了，则通知他醒来
arrMT[index] = wt;
index ++;
}
public synchronized ManTou pop() { //取馒头
while(index == 0) { //篮子空了
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.notify(); //如果产馒头的wait了，则通知他醒来
index --;
return arrMT[index];
}
}

class SyncStack { //篮子
	int index = 0;
	ManTou[] arrMT = new ManTou[6]; //假设这个篮子只能装6个馒头
	
	public synchronized void push(ManTou wt) { //装馒头
		while(index == arrMT.length) { //篮子满了
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.notify(); //如果取馒头的wait了，则通知他醒来
		arrMT[index] = wt;
		index ++;
	}
	
	public synchronized ManTou pop() { //取馒头
		while(index == 0) { //篮子空了
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.notify(); //如果产馒头的wait了，则通知他醒来
		index --;
		return arrMT[index];
		
	}
}

3. 生产者（生产馒头）

生产者需要获取篮子这个对象，而且篮子不能是自己创建的。其Java代码如下：

[java] view plain copy

print ?

class Producer implements Runnable { //生产者
SyncStack ss = null;
Producer(SyncStack ss) {
this.ss = ss;
}
public void run() {
for(int i=0; i<20; i++) { //一共要生成20个
ManTou wt = new ManTou(i);
ss.push(wt);
System.out.println("生产了：" + wt);
try { //生成一个睡1秒，便于观察
Thread.sleep((long) (Math.random() * 1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

class Producer implements Runnable { //生产者
	SyncStack ss = null;
	
	Producer(SyncStack ss) {
		this.ss = ss;
	}
	
	public void run() {
		for(int i=0; i<20; i++) { //一共要生成20个
			ManTou wt = new ManTou(i);
			ss.push(wt);
			System.out.println("生产了：" + wt);
			try { //生成一个睡1秒，便于观察
				Thread.sleep((long) (Math.random() * 1000));
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

4. 消费者（吃馒头）

消费需要获取篮子这个对象，而且这个对象必须与生产者获取的篮子是同一个对象，这样才能信息共享。其Java代码如下：

[java] view plain copy

print ?

class Consumer implements Runnable {
SyncStack ss = null;
Consumer(SyncStack ss) {
this.ss = ss;
}
public void run() {
for(int i=0; i<20; i++) { //一共要吃20个
ManTou wt = ss.pop();
System.out.println("消费了：" + wt);
}
}
}

class Consumer implements Runnable {
	SyncStack ss = null;
	
	Consumer(SyncStack ss) {
		this.ss = ss;
	}
	public void run() {
		for(int i=0; i<20; i++) { //一共要吃20个
			ManTou wt = ss.pop();
			System.out.println("消费了：" + wt);
		}
	}
}

5. 测试运行

主函数Java代码如下：

[java] view plain copy

print ?

public class ProducerConsumer {
public static void main(String[] args) {
SyncStack ss = new SyncStack(); //定义篮子
Producer p = new Producer(ss); //定义生产者
Consumer c = new Consumer(ss); //定义消费者
new Thread(p).start();
new Thread(c).start();
}
}

public class ProducerConsumer {
	public static void main(String[] args) {
		SyncStack ss = new SyncStack(); //定义篮子
		Producer p = new Producer(ss);  //定义生产者
		Consumer c = new Consumer(ss);  //定义消费者
		new Thread(p).start();
		new Thread(c).start();
	}
}

运行上述结果，后台打印如下：

全文完。转载请注明出处。

yuan10277

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
生产者和消费者模式

生产者-消费者模式是一个经典的多线程设计模式，它为多线程的协作提供了良好的解决方案。在生产者-消费者模式中，通常有两类线程，即若干个生产者线程和若干个消费者线程。生产者线程负责提交用户请求，消费者线程负责处理用户请求。生产者和消费者之间通过共享内存缓冲区进行通信。生产者-消费者模式中的内存缓冲区的主要功能是数据在多线程间的共享。此外，通过该缓冲区，可以缓解生产者和消费者之间的性能差。Java多线程...
复制链接

扫一扫

专栏目录