JDK1.5新特性——Lock、Condition接

        我们知道，多线程中往往会对同一资源数据进行操作，这就意味着需要同步处理。
        同步处理的过程：某线程拿到锁，持有锁，进行数据操作，释放锁。
        同步处理的原则：保证对数据操作的完整性。

        以往我们用synchronized修饰函数或定义synchronized语句块来实现同步处理的过程，我们只需要定义怎么处理数据就行了，而不考虑锁什么时候锁上、什么时候打开。同步函数的锁往往是本类对象的this引用或本类的字节码对象。

        而在JDK1.5中，提供了一种锁处理机制，即Lock、Condition接口。这里需要手动上锁、手动开锁。
        而且新特性更加的灵活。举个例子，在多生产多消费的线程中，我们用while循环来判断，用notifyAll()来唤醒所有的线程，那么不能只单单唤醒对方阵营中某一线程吗？而利用Lock、Condition是能实现的。

        这两个接口都是在java.util.concurrent.locks下的，所有使用时需要导包。

1 接口Lock

1.1 方法

1.1.1 void lock()

        获取锁。可以让别的线程无法执行已上锁的代码。

1.1.2 void unlock()

        释放锁。允许别的线程访问此代码。

1.1.3 ConditionnewCondition()

        返回绑定到此Lock实例的新Condition实例。

1.2 实现Lock接口的类

1.2.1 ReentrantLock

        一个可重入的互斥锁Lock，它具有与使用synchronized方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。

        Locklock = newReentrantLock();//父类引用指向子类对象。

        Condition condition =lock.newCondition();

2 接口Condition

2.1 方法

2.1.1 void await() throws InterruptedException

        使当前线程进入阻塞（等待）状态。

2.1.2 void signal()

        唤醒一个等待线程。

2.1.3 void signalAll()

        唤醒所有等待线程。

3 使用方法

class Resource
{
	//公共资源属性
	boolean flag = true; //标记值
	final Lock lock = new ReentrantLock(); //生产一个锁（父类引用指向子类对象）
	final Condition condition = lock.newCondition();//用生成的锁Condition实例
	//同一个锁可以有n个不同的Condition实例，分别对不同的线程起作用哦
	void set(公共资源)
	{
		lock.lock();//加锁
		try
		{
			if(!flag)          //多线程 用while判断
				condition.await(); //满足条件，等待（等待前finally释放锁）
			//对公共资源的操作(写操作，生产)
			flag = false;
			condition.signal();//唤醒其他线程      //多线程 用signalAll()唤醒全部线程
		}
		catch(InterruptedException e)
		{//异常处理：1、try-catch处理 2、throws处理（如下）
		}
		finally
		{
			lock.unlock();//释放锁
		}
	}
	void get() throws InterruptedException //异常处理：抛给调用者处理
	{
		lock.lock();
		try
		{
			if(flag)
				condition.await();
			//对公共资源的操作(读操作，消费)
			flag = true;
			condition.signal();
		}
		finally
		{
			lock.unlock();
		}
	}
}

4 改写程序

4.1 改写单生产单消费的程序

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class Goods
{
	String name;
	int id = 0;
	boolean flag = true;
	final Lock lock = new ReentrantLock();
	final Condition condition = lock.newCondition();
	void set(String name) throws InterruptedException
	{
		lock.lock();
		try
		{
			if(!flag)
				condition.await();
			this.name = name;
			id++;
			System.out.println(Thread.currentThread().getName()+"--商品--"+name+"--"+id);
			flag = false;
			condition.signal();
		}
		finally
		{
			lock.unlock();
		}
	}
	void get()
	{
		lock.lock();
		try
		{
			if(flag)
				condition.await();
			System.out.println(Thread.currentThread().getName()+"--商品--"+name+"--"+id);			flag = true;
			condition.signal();
		}
		catch(InterruptedException e)
		{
		}
		finally
		{
			lock.unlock();
		}
	}
}
class SetGoods implements Runnable
{
	private Goods goods;
	public SetGoods(Goods goods)
	{
		this.goods = goods;
	}
	public void run()
	{
		int n = 500;
		while(n-- > 0)
		{
			try
			{
				goods.set("汉堡");
			}
			catch(InterruptedException e)
			{
			}
		}
	}
}
class GetGoods implements Runnable
{
	private Goods goods;
	public GetGoods(Goods goods)
	{
		this.goods = goods;
	}
	public void run()
	{
		int n = 500;
		while(n-- > 0)
			goods.get();
	}
}
public class Main
{
	public static void main(String[] args)
	{
		Goods goods = new Goods();
		new Thread(new SetGoods(goods), "A生产").start();
		new Thread(new GetGoods(goods), "C消费").start();
	}
}

4.2 改写多生产多消费的程序

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class Goods
{
	String name;
	int id = 0;
	boolean flag = true;
	final Lock lock = new ReentrantLock();
	final Condition condition = lock.newCondition();
	void set(String name) throws InterruptedException
	{
		lock.lock();
		try
		{
			while(!flag)
				condition.await();
			this.name = name;
			id++;
			System.out.println(Thread.currentThread().getName()+"--商品--"+name+"--"+id);
			flag = false;
			condition.signalAll();
		}
		finally
		{
			lock.unlock();
		}
	}
	void get()
	{
		lock.lock();
		try
		{
			while(flag)
				condition.await();
			System.out.println(Thread.currentThread().getName()+"--商品--"+name+"--"+id);			flag = true;
			condition.signalAll();
		}
		catch(InterruptedException e)
		{
		}
		finally
		{
			lock.unlock();
		}
	}
}
class SetGoods implements Runnable
{
	private Goods goods;
	public SetGoods(Goods goods)
	{
		this.goods = goods;
	}
	public void run()
	{
		int n = 500;
		while(n-- > 0)
		{
			try
			{
				goods.set("汉堡");
			}
			catch(InterruptedException e) {}
		}
	}
}
class GetGoods implements Runnable
{
	private Goods goods;
	public GetGoods(Goods goods)
	{
		this.goods = goods;
	}
	public void run()
	{
		int n = 500;
		while(n-- > 0)
			goods.get();
	}
}
public class Main
{
	public static void main(String[] args)
	{
		Goods goods = new Goods();
		new Thread(new SetGoods(goods), "A生产").start();
		new Thread(new SetGoods(goods), "B生产").start();
		new Thread(new GetGoods(goods), "C消费").start();
		new Thread(new GetGoods(goods), "D消费").start();
	}
}

新特性更加的灵活。举个例子，在多生产多消费的线程中，我们用while循环来判断，用notifyAll()来唤醒所有的线程，那么不能只单单唤醒对方阵营中某一线程吗？而利用Lock、Condition是能实现的。

        看4.2改写多生产多消费的程序，也没有体现出比synchronized更加灵活的地方来，依旧是唤醒所有的程序啊？

5 使用方法升级版

class Resource
{
	//公共资源属性
	boolean flag = true;
	final Lock lock = new ReentrantLock();
	final Condition conditionProduce = lock.newCondition(); //lock产生两个Condition对象
	final Condition conditionConsume = lock.newCondition();
	void set(公共资源)
	{
		lock.lock();
		try
		{
			while(!flag)
				conditionProduce.await();//是当前线程等待
			//数据操作
			flag = false;
			conditionConsume.signal();//将对方阵营中的一个线程唤醒
		}
		catch(Exception e) {}
		finally   //必执行代码块
		{
			lock.unlock();
		}
	}
	void get()
	{
		lock.lock();
		try
		{
			while(!flag)
				conditionConsume.await();//是当前线程等待
			//数据操作
			flag = false;
			conditionProduce.signal();//将对方阵营中的一个线程唤醒
		}
		catch(Exception e) {}
		finally   //必执行代码块
		{
			lock.unlock();
		}
	}
}

一个lock实例产生两个Condition对象，分别对不同的线程加以标记，从而进行不同的操作。

6 你会再次改写多生产多消费的例子吗？