java.util.concurrent(二) Lock

           在多线程编程中常常需要进行同步而锁定某个对象，通常采用synchronized来实现，部分情况下采用Java.util.concurrent.lock更加合适。ReentrantLock实现了Lock接口、是常用的实现类。

           

           Lock和synchronized有个明显的区别在于----lock必须在finally里面释放，如若不在finally中释放，则操作中抛出异常、锁又可能永远得不到释放，这点非常重要。

 

Lock lock = new ReentrantLock();
lock.lock();
try {
     // ...
} 
finally {
     lock.unlock();
}

 

 

          Lock的Condition使得Lock在使用的时候更加的灵活。Lock与synchronized的功能类似、进行同步，Condition则用于线程间通信、其提供的await()、signal()方法相对于wait()、notify()方法。condition与Lock绑定使用、一个Lock可通过Lock.newCondition()方法绑定多个condition，即相当于同一个锁有多个等待队列。相比较于synchronized灵活许多。下面以典型的生产者-消费者问题为例做个比较：

package producerConsumer;

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import producerConsumer.ProducerConsumer.Consumer;
import producerConsumer.ProducerConsumer.Producer;

public class ProducerConsumerLock {
	private static Queue<Object> myList = new LinkedList<Object>();
	private static final int MAX = 1;
	private static Lock lock = new ReentrantLock();
	private static Condition full = lock.newCondition();
	private static Condition empty = lock.newCondition();
	
	public static void main(String[] args) {
		for(int i = 0; i < 10; i++) {
			new Thread(new Producer(), "Producer" + i).start();
			new Thread(new Consumer(), "Consumer" + i).start();
		}
	}
	
	static class Producer extends Thread {
		public void run() {
			while(true) {
				lock.lock();
				try {
					while(myList.size() == MAX) {
						System.out.println("queue is full...");
						full.await();
					}
					Thread.currentThread().sleep(Math.round(100));
					Object o = new Object();
					myList.add(o);
					System.out.println("Producer-MQsize: " + myList.size() + "       name: " + Thread.currentThread().getName());
					empty.signal();
				} catch(Exception e) {
					e.printStackTrace();
				} finally {
					lock.unlock();
				}
			
			}
		}
	}
	
	static class Consumer extends Thread {
		public void run() {
			while(true) {
				lock.lock();
				try {
					while(myList.size() == 0) {
						System.out.println("queue is empty...");
						empty.await();
					}
					Thread.currentThread().sleep(Math.round(1000));
					Object o = myList.remove();
					System.out.println("Consumer-MQsize: " + myList.size() + "       name: " + Thread.currentThread().getName());
					full.signal();
				} catch(Exception e) {
					e.printStackTrace();
				} finally {
					lock.unlock();
				}
			}
		}
	}
}

 

           ReentrantLock通过其构造器的参数设置，可实现公平锁的功能，公平锁使线程按照请求锁的顺序依次获得锁。公平锁的性能开销非常大，因此ReentrantLock的默认设置时不公平的，除非公平对你的算法非常重要、必须严格按照线程排队的顺序进行服务，除此之外一般都不采用公平锁。

Lock lock = new ReentrantLock(false);//设置为true则为公平锁

 

          Lock的tryLock()也是一大特征、尝试获得锁，该方法立即返回结果、也可设置等待时间。

          Lock的性能方面表现也比synchronized优异，但是一般情况下不使用Lock。Lock与synchronized的具体区别以及选择如下 ：http://www.ibm.com/developerworks/cn/java/j-jtp10264/index.html