Lock和Condition

1、jdk1.5之前用synchornized和voatile来控制共享对象的并发访问，jdk5.0提供了ReentrantLock。

2、Lock和ReentrantLock：

?

Lock接口里定义了一些抽象的锁操作，有无条件、可轮询、定时、可中断的锁获取操作，ReentrantLock实现了Lock接口，获得ReetrantLock的锁与进入synchronized代码块有相同的内存语义，释放ReentrantLock锁和退出sychronized代码块有相同的内存语义。

?

从上面可以看出，Lock提供了不同形式获取锁方式，而之前通过synchronied修饰代码块的时候，如果有一个线程已经获取对象锁，其他线程访问共享对象的时候就必须无限等待，等待当前线程释放对象锁后再去进行竞争，不能中断那些等待获取锁的线程，而Lock提供了一些其他方法，比如tryLock()：如果当前锁可用则获取并返回true，如果不可用则返回false。在方法前加上while(true)就可以实现轮询获取锁。

package com.sxit.test;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/** * @功能：tryLock使用 * @作者: smile * @时间：2013-4-18 下午4:03:18 * @版本：1.0 */public class TryLockDemo {// 锁private final Lock lock = new ReentrantLock();public void take() {if (lock.tryLock()) {try {System.out.println("take获取到锁...");} catch (Exception e) {e.printStackTrace();} finally{lock.unlock();}}else{System.out.println("take没有获取到锁...");}}public void put() {if (lock.tryLock()) {try {System.out.println("put获取到锁...");} catch (Exception e) {e.printStackTrace();} finally{lock.unlock();}}else{System.out.println("put没有获取到锁...");}}public static void main(String[] args) {TryLockDemo t = new TryLockDemo();Take take = new Take(t);Put put = new Put(t);Thread t1 = new Thread(take);Thread t2 = new Thread(put);t1.start();t2.start();}}class Take implements Runnable {private TryLockDemo t;public Take(TryLockDemo t) {this.t = t;}@Overridepublic void run() {while (true) {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}t.take();}}}class Put implements Runnable {private TryLockDemo t;public Put(TryLockDemo t) {this.t = t;}@Overridepublic void run() {while (true) {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}t.put();}}}

?

?

通过使用tryLock方法就可以让那些等待线程可以不用再无限期等待，可以继续轮询获取锁或者做其他操作。

tryLock还有一个指定时间获取锁的方法，在指定时间内如果锁可用则返回，不可用则线程处于休眠状态。

package com.sxit.test;import java.util.concurrent.TimeUnit;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/** * @功能：tryLock使用 * @作者: smile * @时间：2013-4-18 下午4:03:18 * @版本：1.0 */public class TryLockDemo {// 锁private final Lock lock = new ReentrantLock();public void take() throws Exception {if (lock.tryLock(100,TimeUnit.NANOSECONDS)) {try {System.out.println("take获取到锁...");} catch (Exception e) {e.printStackTrace();} finally{lock.unlock();}}else{System.out.println("take 100纳秒内没有获取到锁...");}}public void put() throws Exception {if (lock.tryLock(100,TimeUnit.NANOSECONDS)) {try {System.out.println("put获取到锁...");} catch (Exception e) {e.printStackTrace();} finally{lock.unlock();}}else{System.out.println("put 100纳秒内没有获取到锁...");}}public static void main(String[] args) {TryLockDemo t = new TryLockDemo();Take take = new Take(t);Put put = new Put(t);Thread t1 = new Thread(take);Thread t2 = new Thread(put);t1.start();t2.start();}}class Take implements Runnable {private TryLockDemo t;public Take(TryLockDemo t) {this.t = t;}@Overridepublic void run() {while (true) {try {t.take();} catch (InterruptedException e) {e.printStackTrace();} catch (Exception e) {e.printStackTrace();}}}}class Put implements Runnable {private TryLockDemo t;public Put(TryLockDemo t) {this.t = t;}@Overridepublic void run() {while (true) {try {t.put();} catch (InterruptedException e) {e.printStackTrace();} catch (Exception e) {e.printStackTrace();}}}}

?还有一种是lockInterruptibly()：可中断的锁获取，当线程在获取锁的时候，如果有其他线程调用该线程的interrupt方法中断线程，这时不会再去尝试获取锁，而会抛出一个InterruptedException异常。而正常的lock()方法不允许中断线程，即使调用了interrupt()方法还是会继续尝试获取锁，最后获取到锁后再把线程设置为interrupt状态，然后再中断。 而且使用lockInterruptibly获取锁的时候，如果线程被中断了，会抛出异常，并且会把线程的中断状态移除。

package com.sxit.test;import java.util.concurrent.TimeUnit;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/** * @功能：lockInterruptibly使用 * @作者: smile * @时间：2013-4-18 下午4:03:18 * @版本：1.0 */public class TryLockDemo {// 锁private final Lock lock = new ReentrantLock();public void interrupt() {try {lock.lockInterruptibly();System.out.println("打印一下");//中断前状态System.out.println("中断前状态:"+Thread.currentThread().isInterrupted());//中断当前线程Thread.currentThread().interrupt();//中断后状态System.out.println("中断后状态:"+Thread.currentThread().isInterrupted());} catch (InterruptedException e) {e.printStackTrace();} finally {//中断最后状态System.out.println("中断最后状态:"+Thread.currentThread().isInterrupted());lock.unlock();}}public static void main(String[] args) {TryLockDemo t = new TryLockDemo();Iterrupt i = new Iterrupt(t);Thread t1 = new Thread(i);t1.start();}}class Iterrupt implements Runnable {private TryLockDemo t;public Iterrupt(TryLockDemo t) {this.t = t;}@Overridepublic void run() {while (true) {try {t.interrupt();} catch (Exception e) {e.printStackTrace();}}}}

?

还有一个方法是newCondition（），返回一个Condition实例。这个方法时返回一个绑定这个Lock实例的条件对象实例。

?

之前使用synchronized的时候，比如生产者和消费者模型中有take和put两个操作，当队列为空时会调用list.wait()，当队列满的时候也会调用list.wait()，就是把当前线程加入到list对象的锁等待池中，而当队列不为空或者队列不是满的时候我们会调用notifyAll或者notify，比如take中调用notify时，它会从锁等待池中随机选一个线程让它进入可运行状态，等待锁释放后去竞争锁，但是这里就有一个问题，其实我们这里需要唤醒的是take线程，但是使用notify的时候随机性很强，很有可能他唤醒的是一个put线程或者别的线程，当然可以使用notifyAll，他会唤醒对象锁池中的所有线程，但是等锁释放后，还是只有一个锁能够竞争到资源进入运行状态，所以这样不能明确快速的指定具体要唤醒的线程。

?

现在jdk5.0提供了Condition，通过lock.newCondition()可以获得绑定当前锁的条件对象，每个条件对象都维护相对于自己这个条件的线程等待池，比如队列非空，可以创建一个Condition not_empty = lock.newCondition();? 当take的时候如果队列为空，则not_empty.await()，这样当前线程由这个条件对象来维护，当队列非空的时候就可以通过调用not_empty.sigal()来唤醒那些需要取元素的线程。这样就能把各种线程在不同条件下进行细致分类，灵活操作。不用像之前那样直接用个notifyAll，使用notifyAll把不同条件需求的线程全绑定在一个队列中，一个条件满足就需要唤醒全部线程，然后相互竞争锁，既不精确性能也差。

?

一个简单的生产者和消费者模型实例：

package com.sxit.test;import java.util.ArrayList;import java.util.List;import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/** * @功能：使用Lock Conditon * @作者: smile * @时间：2013-4-18 下午5:18:07 * @版本：1.0 */public class Test05 {public static Lock lock = new ReentrantLock();;// 容器已满  定product程public static Condition full = lock.newCondition();// 容器为空  定consumer程public static Condition empty = lock.newCondition();public static void main(String[] args) {List list = new ArrayList(12);Product product = new Product(list, 10);Consumer consumer = new Consumer(list, 0);Thread t1 = new Thread(product);Thread t2 = new Thread(consumer);t1.start();t2.start();}// 生产static class Product implements Runnable {private List list;private int maxCount;public Product(List list, int maxCount) {super();this.list = list;this.maxCount = maxCount;}@Overridepublic void run() {while(true){if (lock.tryLock()) {try {if (getSize() >= maxCount) {System.out.println("容器已，product程加入池中...");full.await();}System.out.println("始生....");list.add(new Object());//醒消者程empty.signal();} catch (InterruptedException e) {e.printStackTrace();} finally {lock.unlock();}} else {System.out.println("未获取生产资格...");}}}public int getSize() {return list.size();}}// 消费static class Consumer implements Runnable {private List list;private int minCount;public Consumer(List list, int minCount) {super();this.list = list;this.minCount = minCount;}@Overridepublic void run() {while(true){if (lock.tryLock()) {try {if (getSize() <= minCount) {System.out.println("容器已空，consumer程加入池中...");empty.await();}System.out.println("始消....");list.remove(0);//醒生者程full.signal();} catch (InterruptedException e) {e.printStackTrace();} finally {lock.unlock();}} else {System.out.println("未获取消费资格...");}}}public int getSize() {return list.size();}}}

?

?

?

?

?

?

?