多线程__【线程间通信】【等待唤醒机制】【多生产多消费】【Lock&Condition接口】

线程间通信：

对资源同时输入输出

一， wait（） notify（） notify all（）是用来操作线程的，定义在Object类中

1，这些方法存在于同步中

2，使用这些方法必须要标示所属的同步锁

3,锁可以是任意对象，所以任意对象调用的方法一定定义在Object类中

二，wait （）和sleep（）区别；

都会抛出异常，需要处理，都会使线程进入冻结状态

1，wait（）释放资源，释放锁，需要被notify()唤醒

2，sleep()释放资源，不释放锁，只是作一段时间的休眠，休眠完后继续执行。

3，yield(): 释放锁，使当前线程马上回到就绪状态，也可能马上再执行。 

暂停当前正在执行的线程，并执行其他线程

在同步代码块中，只要是特有对象都可以作为同步锁，因为要保证锁的唯一性

等待唤醒机制

使用标记flag，使输入线程和输出线程交替执行并执行完毕后互相唤醒对方

单一同步只能保证对象属性的正确，不能保证输入与输出一对一，加入等待唤醒后能够实现单输入单输出一对一，但不能解决多输入多输出的协调

单生产者单消费者 if ...notify()

输入输出示例：

class Rec
{
	private String name;
	private String sex;
	private boolean flag=false;

	public synchronized void set(String name,String sex)
	{
		if (flag)
			try{this.wait();}//wait()和sleep()会抛异常
			catch (Exception e){}
		this.name=name;
		this.sex=sex;
		flag=true;
		this.notify();
	}

	public synchronized void out()
	{
		if (!flag)
			try{this.wait();}
			catch (Exception e){}
		System.out.println(name+"......"+sex+Thread.currentThread().getName());
		flag=false;
		this.notify();
	}
}
//class Input/Output省略
class InputOutputDemo2
{
	public static void main(String[] args) 
	{
		Rec r= new Rec();
		
		new Thread(new Input(r)).start();参数传递可以直接嵌套，优化代码
		new Thread(new Output(r)).start();
	}
}//单一同步只能保证对象属性的正确，不能保证输入与输出一对一，加入等待唤醒后能够实现单输入单输出一对一，但不能解决多输入多输出的协调

多生产者 多消费者的问题

while...notifyAll()

相对于单生产单消费的问题，多生产多消费的情况会每次notify（）唤醒的线程都不确定，有可能是本方也有可能是对方，会发生  冻结状态导致的不同步，不能对应输出

所以每次线程被唤醒后执行时都要对标记进行判断，如果唤醒的是本方线程，由于标记未改变仍然不能执行。从而保证双方线程交替执行

但是使用while标记判断如果只随机notify()随机唤醒了一个线程，一旦唤醒的是本方线程，就会导致线程全部处于临时阻塞状态（没有了执行权），所以使用while时要使用notifyAll()

示例：

		while(flag)//标记判断
			try{this.wait();}
			catch (Exception e){}
		//要执行的程序方法体；
		flag = true;//改变标记
		this.notifyAll();//唤醒全部

JDK5.0新增的两个接口

功能更加强大的锁，更加直观的显式锁，将锁进行了对象的封装，并且将锁的操作也封装成了对象

lock接口替代synchronized同步锁，

Condition接口替代Object监视器方法

wait() notify() notifyAll()

await() signal() signalAll()

从Lock 创建锁从lock接口的方法newCondition()获取实例来操作锁，Lock的强大之处在于能够获取多个实例来操作同一个锁，可以用来对指定任务进行控制。

await() 或者signal()对方（指定的任务），不用唤醒全部，本方只唤醒对方

	private Lock lock=new ReentrantLock();//创建锁
	private Condition condition_pro = lock.newCondition();//通过锁获取Condition实例
	private Condition condition_con = lock.newCondition();//一锁多用，互相唤醒

多生产多消费升级方案

class Resource
{
	private String name;
	private int count;
	private boolean flag = false;
	
	private Lock lock=new ReentrantLock();//创建锁
	private Condition condition_pro = lock.newCondition();//通过锁获取Condition实例
	private Condition condition_con = lock.newCondition();//一锁多用，互相唤醒

	public void set(String name)throws InterruptedException
	{
		lock.lock();//
		try
		{
			while(flag)
			condition_pro.await();//生产者等待
			this.name=name+"..."+count++;
			System.out.println(Thread.currentThread().getName()+"..producer.."+this.name);
			flag = true;
			condition_con.signal();//唤醒消费者	
		}
		finally//	释放锁的动作一定要执行
		{
			lock.unlock();//解锁
		}
	}

	public void get()throws InterruptedException
	{	
		lock.lock();
		try
		{
			while(!flag)
			condition_con.await();
			System.out.println(Thread.currentThread().getName()+".消费者."+this.name);
			flag = false;
			condition_pro.signal();
		}
		finally
		{
			lock.unlock();
		}
	}
}

释放锁的动作一定要执行

【代码优化小结】：

应用封装，即将有共性的内容封装起来，在需要的时候调用。

善用匿名对象，对于直接使用的对象参数采用匿名减少代码量

善用接口类型和类类型的参数传递