马士兵生产者消费者

最新推荐文章于 2020-04-13 17:44:27 发布

阿O_不拽

最新推荐文章于 2020-04-13 17:44:27 发布

阅读量1k

点赞数

CC 4.0 BY-SA版权

分类专栏：马士兵生产者消费者

本文链接：https://blog.youkuaiyun.com/dreamoftch/article/details/12615843

马士兵同时被 2 个专栏收录

1 篇文章

订阅专栏

生产者消费者

1 篇文章

订阅专栏

本文介绍了一个基于生产者消费者模式的简单实现案例，使用Java语言，通过同步机制保证线程安全。生产者负责向共享容器中添加元素，而消费者从容器中移除元素，通过wait和notify确保线程间的正确同步。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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();
	}
}

class WoTou {
	int id;

	WoTou(int id) {
		this.id = id;
	}

	public String toString() {
		return "WoTou : " + id;
	}
}

class SyncStack {
	int index = 0;
	WoTou[] arrWT = new WoTou[6];

	public synchronized void push(WoTou wt) {
		while (index == arrWT.length) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.notifyAll();
		arrWT[index] = wt;
		System.out.println("set: " + arrWT[index]);
		index++;
	}

	public synchronized WoTou pop() {
		while (index == 0) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.notifyAll();
		index--;
		System.out.println("get :" + arrWT[index]);
		return arrWT[index];
	}
}

class Producer implements Runnable {
	SyncStack ss = null;

	Producer(SyncStack ss) {
		this.ss = ss;
	}

	public void run() {
		for (int i = 0; i < 20; i++) {
			WoTou wt = new WoTou(i);
			ss.push(wt);
			try {
				Thread.sleep((int) (Math.random() * 200));
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

class Consumer implements Runnable {
	SyncStack ss = null;

	Consumer(SyncStack ss) {
		this.ss = ss;
	}

	public void run() {
		for (int i = 0; i < 20; i++) {
			WoTou wt = ss.pop();
			try {
				Thread.sleep((int) (Math.random() * 1000));
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

下面是自己的demo:

import org.apache.log4j.Logger;


public class Consumer implements Runnable{
	private Container container;
	Logger log = Logger.getLogger(Consumer.class);
	
	public Consumer(Container container){
		this.container = container;
	}
	@Override
	public void run() {
		for(int i=0;i<10;i++){
			try {
				Thread.sleep((int) (Math.random() * 1000));
				container.get();
				//log.info("消费了："+container.get());
			}catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

}

import java.util.ArrayList;
import java.util.List;

import org.apache.log4j.Logger;

public class Container {
	private List<Food> container;
	Logger log = Logger.getLogger(Container.class);

	public Container(List<Food> container){
		this.container = container;
	}
	
	public synchronized Food get() throws Exception{
		if(container == null){
			container = new ArrayList<Food>();
		}
		while(container.isEmpty()){
			this.wait();
		}
		Food food = container.remove(container.size()-1);
		log.info("get food:"+food+",container:"+container);
		this.notifyAll();
		return food;
	}
	
	public synchronized void set(Food food) throws Exception{
		if(container == null){
			container = new ArrayList<Food>();
		}
		while(container.size() >= 10){
			this.wait();
		}
		log.info("set food: "+food+",container:"+container);
		container.add(food);
		this.notifyAll();
	}
}

public class Food {

	private int id;

	public Food(int id){
		this.id = id;
	}
	
	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	@Override
	public String toString() {
		return "Food [id=" + id + "]";
	}
	
}

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ProducerConsumerTest {

	public static void main(String[] args) {
		List<Food> list = new ArrayList<Food>();
		Container container = new Container(list);
		Producer p = new Producer(container);
		Consumer c = new Consumer(container);
		//new Thread(p).start();
		//new Thread(p2).start();
		//new Thread(c).start();
		ExecutorService pool = Executors.newFixedThreadPool(2);
		pool.execute(p);
		pool.execute(c);
	}
	
}