Java生产者与消费者

我们先来了解一下Java的线程同步机制(synchronized)：

      一段synchronized的代码被一个线程执行之前，他要先拿到执行这段代码的权限，在 java里边就是拿到某个同步对象的锁（一个对象只有一把锁）； 如果这个时候同步对象的锁被其他线程拿走了，他（这个线程）就只能等了（线程阻塞在锁池 等待队列中）。 取到锁后，他就开始执行同步代码(被synchronized修饰的代码）；线程执行完同步代码后马上就把锁还给同步对象，其他在锁池中 等待的某个线程就可以拿到锁执行同步代码了。这样就保证了同步代码在统一时刻只有一个线程在执行。

我们先搞清楚一下几个函数：  

      1、sleep(long n): 让当前线程睡眠n毫秒，释放cpu执行权，不释放锁。

      2、A.wait()：释放cpu执行权，释放锁（假设此处由对象A充当锁）。  

      3、B.notify()：唤醒以B对象为锁的等待队列中一个正在wait中的线程（比如有一个生产者线程中的A.wait()，那么消费者中              的B.notify()并不能唤醒正在wait的生产者线程）。     

      4、notifyAll()：唤醒以B对象为锁的等待队列中所有正在wait的线程。

//生产者和消费者问题

class Buffer{
	int cap = 0;    //缓冲池的容量
	int count = 0;  //缓冲池的产品个数
	
	public int getCount() {
		return count;
	}
	
	public void setCount(int count) {
		this.count = count;
	}
	public Buffer(int cap) {
		this.cap = cap;
	}
	
	public void setCap(int cap) {
		this.cap = cap;
	}
	
	public int getCap() {
		return this.cap;
	}
}

//生产者
class producer implements Runnable{
	Buffer buf;
	public producer(Buffer buf) {
		this.buf = buf;
	}
	@Override
	public void run() {
		while(true) {
			try {
				Thread.currentThread().sleep(500);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		    produce();
		}
	}
	
	private void produce() {
		synchronized(buf) {
				if(buf.getCount() >= buf.getCap()) {
					try {
						//System.out.println("容量：" + buf.getCap() + "    产品个数：" + buf.getCount());
						buf.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					
			    }
				else {
					int i = buf.getCount();
					++i;
				    System.out.println(Thread.currentThread().getName() + "生产了第" + i + "个产品");
				    buf.setCount(i); 
				    buf.notify();
				}
	    }
	}
}

//消费者
class consumer implements Runnable{
	Buffer buf;
	public consumer(Buffer buf) {
		this.buf = buf;
	}
	@Override
	public void run() {
		while(true) {
			try {
				Thread.currentThread().sleep(500);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		    consume();
		}
	}
	
	private void consume() {
		synchronized(buf) {
		//System.out.println("此时的产品数" + buf.getCount());
				if(buf.getCount() <= 0) {
					try {
						buf.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
			    }
				else {
					int i = buf.getCount();
				    System.out.println(Thread.currentThread().getName() + "消费了第" + i + "个产品");
				    i--;
				    buf.setCount(i);
				    buf.notify();
				}
		}
	}
}




public class ProducerAndConsumer {

	public static void main(String[] args) {
        Buffer buf = new Buffer(20);
        producer p = new producer(buf);
        consumer c = new consumer(buf);
        
        Thread t1 = new Thread(p);  //生产者线程
        Thread t2 = new Thread(c);  //消费者线程
        
        t1.setName("生产者");
        t2.setName("消费者");
        
        t1.start();
        
        t2.start();
	}

}