生产者消费者模式sychronized实现 java

生产者消费者模式sychronized实现 java

相信大家都对消费者和生产者模式有一定了解，这个场景经常会用到多线程，而且因为涉及到共享资源的获取和修改，必然是需要线程同步的，那这边我就用synchronized来试下消费者和生产者，希望大家能看明白，程序中有注释,基本上能看懂的，主要是对共享对象buffer中的两个方法进行同步

代码：

import java.util.Date;
import java.util.LinkedList;
import java.util.List;

//生产者消费者模式
public class Producer_Consumer {
	public static void main(String[] args) {
		Buffer buffer = new Buffer(10);
		Producer producer = new Producer(buffer);
		Consumer consumer = new Consumer(buffer);
		//创建线程执行生产和消费
		for(int i = 0; i < 3; i++) {
			new Thread(producer,"Producer-"+i).start();
		}

for(int i = 0; i < 3; i++) {
			new Thread(consumer,"Consumer-"+(i+3)).start();
		}
	} 
}

//模拟生产者消费者的对象
class Buffer {
	private int maxSize;
	private List<Date> storage;
	Buffer(int size) {
		maxSize = size;
		storage  = new LinkedList<>();
	}
	//生产方法
	public synchronized void put () {
		try {
			while (storage.size() == maxSize) {//如果队列满了
				System.out.println(Thread.currentThread().getName()+": wait \n");
				wait();//阻塞线程
			}
			storage.add(new Date());
			System.out.println(Thread.currentThread().getName()+": put:"+storage.size()+"\n");
			Thread.sleep(1000);
			notifyAll();//唤起线程
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	//消费方法
	public synchronized void take () {
		try {
			while (storage.size() == 0) {//如果队列空了
				System.out.println(Thread.currentThread().getName()+": wait \n");
				wait();//阻塞线程
			}
			Date d = ((LinkedList<Date>)storage).poll();
			System.out.println(Thread.currentThread().getName()+": take:"+storage.size()+"\n");
			Thread.sleep(1000);
			notifyAll();//唤起线程
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

//生产者
class Producer implements Runnable {
	private Buffer buffer;
	Producer(Buffer b) {
		buffer = b;
	}
	@Override
	public void run() {
		while(true) {
			buffer.put();
		}
	}
}

//消费者
class Consumer implements Runnable {
	private Buffer buffer;
	Consumer(Buffer b) {
		buffer = b;
	}
	@Override
	public void run () {
		while (true) {
			buffer.take();
		}
	}
}

输出结果：

Producer-0: put:1


Producer-0: put:2


Producer-0: put:3


Producer-0: put:4


Producer-0: put:5


Producer-0: put:6


Producer-0: put:7


Producer-0: put:8


Producer-0: put:9


Producer-0: put:10


Producer-0: wait 


Consumer-5: take:9


Consumer-5: take:8


Consumer-5: take:7


Consumer-5: take:6


Consumer-5: take:5


Consumer-5: take:4


Consumer-5: take:3


Consumer-5: take:2


Consumer-5: take:1


Consumer-5: take:0


Consumer-5: wait 


Consumer-4: wait 


Consumer-3: wait 


Producer-2: put:1


Producer-2: put:2


Producer-2: put:3


Producer-2: put:4


Producer-2: put:5


Producer-2: put:6


Producer-2: put:7


Producer-2: put:8


Producer-2: put:9


Producer-2: put:10


Producer-2: wait 


Producer-1: wait 


Consumer-3: take:9


Consumer-3: take:8


Consumer-3: take:7


Consumer-3: take:6


Consumer-3: take:5


Consumer-3: take:4


Consumer-3: take:3


Consumer-3: take:2


Consumer-3: take:1


Consumer-3: take:0


Consumer-3: wait 


Consumer-4: wait 


Consumer-5: wait 


Producer-0: put:1


Producer-0: put:2


Producer-0: put:3


Consumer-5: take:2


Consumer-5: take:1


Consumer-5: take:0


Consumer-5: wait 


Consumer-4: wait 


Consumer-3: wait 


Producer-1: put:1


Producer-1: put:2


Producer-1: put:3


Producer-1: put:4