JDK 1.5提供了多线程升级方案
将同步synchronized替换成了显示的Lock操作。可以实现唤醒、冻结指定的线程。
Lock接口
Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构，可以具有差别很大的属性，可以支持多个相关的 Condition 对象。
线程间通信Condition接口
Condition可以替代传统的线程间通信，用await()替换wait()，用signal()替换notify()，用signalAll()替换notifyAll()。该对象可以通过Lock锁进行获取。
传统线程的通信方式，Condition都可以实现。
注意，Condition是被绑定到Lock上的，要创建一个Lock的Condition必须用newCondition()方法。
ReentrantLock类
Java.util.concurrent.lock 中的Lock 框架是锁定的一个抽象，它允许把锁定的实现作为 Java 类，而不是作为语言的特性来实现。这就为Lock 的多种实现留下了空间，各种实现可能有不同的调度算法、性能特性或者锁定语义。
ReentrantLock 类实现了Lock ，它拥有与synchronized 相同的并发性和内存语义，但是添加了类似锁投票、定时锁等候和可中断锁等候的一些特性。此外，它还提供了在激烈争用情况下更佳的性能。(换句话说，当许多线程都想访问共享资源时，JVM 可以花更少的时候来调度线程，把更多时间用在执行线程上。)
用法示例：
private Lock lock = new ReentrantLock();//定义多态ReentrantLock类对象
private Condition cond_pro = lock.newCondition();//Condition是被绑定到Lock上的，要创建一个Lock的Condition必须用Lock对象的newCondition()方法。
private Condition cond_con = lock.newCondition();//一个lock可以有多个相关的condition
首先创建一个ReentrantLock类的多态对象，即建立一把锁。然后将这把锁与两个Condition对象关联。
实例：
import java.util.concurrent.locks.*;
class ProducerConsumerDemo
{
public static void main(String[] args)
{
Resource r = new Resource();
Producer pro = new Producer(r);//生产者对象
Consumer con = new Consumer(r);//消费者对象
Thread t1 = new Thread(pro);
Thread t2 = new Thread(pro);
Thread t3 = new Thread(con);
Thread t4 = new Thread(con);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class Resource
{
private String name;
private int count = 1;
private boolean flag = false;
private Lock lock = new ReentrantLock();//定义一个实现Lock接口的ReentrantLock类对象
private Condition cond_pro = lock.newCondition();//Condition是被绑定到Lock上的，要创建一个Lock的Condition必须用Lock对象的newCondition()方法。
private Condition cond_con = lock.newCondition();//一个lock可以有多个相关的condition
public void set(String name) throws InterruptedException//生产方法
//注意这里抛出await()方法异常声明，交给调用者处理
{
lock.lock(); //手动加同步锁
try
{
while (flag) //if→while 此时若生产完一个以后唤醒了另一个生产者，则再次判断，避免了两个生产者同时生产
cond_pro.await(); //冻结生产方法
this.name = name+"____"+count++;
System.out.println(Thread.currentThread().getName()+"_______"+"生产者"+this.name);
flag = true;
cond_con.signal(); //唤醒消费方法，利用了condition的signal()指定唤醒对象
}
finally //
{
lock.unlock();
}
}
public void out()throws InterruptedException
{
lock.lock();
try
{
while (!flag)
cond_con.await();
System.out.println(Thread.currentThread().getName()+"______"+"消费者"+this.name);
flag = false;
cond_pro.signal();
}
finally //释放锁必须得到执行
{
lock.unlock();
}
}
}
class Consumer implements Runnable
{
private Resource res;
public Consumer(Resource res)
{
this.res = res;
}
public void run()
{
while (true)
{
try //由于out()方法抛出了异常声明，这里必须捕获。
{
res.out();
}
catch (InterruptedException e)
{
}
}
}
}
class Producer implements Runnable
{
private Resource res;
public Producer(Resource res)
{
this.res = res;
}
public void run()
{
while (true)
{
try
{
res.set("+商品+");
}
catch (InterruptedException e)
{
}
}
}
}
执行上述代码，观察结果：
可以看到，多个线程同时生产、消费，由于指定唤醒互异线程，因此并不会引起错误。
