线程笔记2--线程的通信（生产者与消费者案例分析）

线程通信

1、线程通信:不同的线程执行不同的任务,如果这些任务有某种关系,线程之间必须能够通信,协调完成工作，线程通信是相互间状态的切换。

2、线程通信-wait和notify方法介绍:

java.lang.Object类提供类两类用于操作线程通信的方法.

wait():执行该方法的线程对象释放同步锁,JVM把该线程存放到等待池中,等待其他的线程唤醒该线程（失去CPU和锁）.

notify:执行该方法的线程随机唤醒在等待池中等待的任意一个线程,把线程转到锁池中等待.

notifyAll():执行该方法的线程唤醒在等待池中等待的所有的线程,把线程转到锁池中等待.

!注意:上述方法只能被同步监听锁对象来调用,否则报错IllegalMonitorStateException...

3、生产者与消费者案例分析：

为什么生产者不直接把数据给消费者,而是先把数据存储到共享资源中,然后,消费者再从共享资源中取出数据,再消费.

在这里体现了面向对象的设计理念:低耦合.

       高(紧)耦合: 直接使用生产者把肉包子给消费者,那么生产者中得存在消费者的引用,同理,消费者要消费生产者生产的肉包子,消费者中也得存在生产者对象的引用.

       低(松)耦合:使用一个中间对象,屏蔽了生产者和消费者直接的数据交互.  

Demo:

public class ThreadDemo1 {

	public static void main(String[] args) {
		Product pro = new Product();
		Producers ps = new Producers(pro);
		Salers ss = new Salers(pro);
		
		Thread th1 = new Thread(ps);
		Thread th2 = new Thread(ss);
		th1.start();
		th2.start();
	}

}

class Product {
	private int id;
	private String name;
	private boolean flag;
	private int i;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public boolean isFlag() {
		return flag;
	}
	public void setFlag(boolean flag) {
		this.flag = flag;
	}
	
	//produce
	synchronized public void produce() {
		if (this.isFlag()) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		this.setName("小火炮");
		this.setId(++i);
		System.out.println("produce: "+this.getName()+this.getId());
		this.setFlag(true);
		this.notify();
	}
	
	//sale
	synchronized public void sale() {
		if (!this.isFlag()) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		System.out.println("sale: "+this.getName()+this.getId());
		this.setFlag(false);
		this.notify();
	}
}

class Producers implements Runnable{
	private Product pro;
	public Producers(Product pro) {
		this.pro = pro;
	}
	@Override
	public void run() {
		while(true) {
			pro.produce();
		}
	}
	
}
class Salers implements Runnable{
	private Product pro;
	public Salers(Product pro) {
		this.pro = pro;
	}
	@Override
	public void run() {
		while(true) {
			pro.sale();
		}
	}
	
}

4、线程通信-使用Lock和Condition接口:

wait和notify方法,只能被同步监听锁对象来调用,否则报错IllegalMonitorStateException.

那么现在问题来了,Lock机制根本就没有同步锁了,也就没有自动获取锁和自动释放锁的概念.

因为没有同步锁,所以Lock机制不能调用wait和notify方法.

解决方案:Java5中提供了Lock机制的同时提供了处理Lock机制的通信控制的Condition接口.

1):使用Lock机制取代synchronized 代码块和synchronized 方法.

2):使用Condition接口对象的await,signal,signalAll方法取代Object类中的wait,notify,notifyAll方法.

Demo:

多个生产者和消费者案例：

//产品：
public class Product {
	private String name;
	private String country;
	private boolean isEmpty = true;
	Lock lock = new ReentrantLock();
	Condition cd_p = lock.newCondition();
	Condition cd_s = lock.newCondition();
	
	public void pro(String n, String c){
		lock.lock();
		try {
			while(!isEmpty){
				cd_p.await();
			}
			name = n;
			Thread.sleep(10);
			country = c;
			isEmpty = false;
			cd_s.signalAll();
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	
	public void sale(){
		lock.lock();
		try {
			while(isEmpty){
				cd_s.await();
			}
			Thread.sleep(10);
			System.out.println(this.name+"---"+this.country);
			isEmpty = true;
			cd_p.signalAll();
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
}

//消费者：
public class Consumer extends Thread{
	Product p = null;


	public Consumer(Product p) {
		this.p = p;
	}
	
	public void run() {
		for (int i = 0; i <25; i++) {
			p.sale();
		}
	}
}

//生产者：
public class Producer extends Thread{
	Product p = null;

	public Producer(Product p) {
		this.p = p;
	}
	
	public void run() {
		for(int i = 0; i <25; i++){
			if(i%2==0){
				p.pro("火炮", "中国");
			}else{
				p.pro("香肠", "四川");
			}
		}
	}
}

//测试类
public class Test {
	public static void main(String[] args) {
		Product p = new Product();
		new Consumer(p).start();
		new Consumer(p).start();
		new Producer(p).start();
		new Producer(p).start();
	}
}