Lock

一，synchronized的缺陷

如果一个代码块被synchronized修饰，当一个线程获取了对应的锁，并执行该代码块，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况

1.获取锁的线程执行完该代码块，然后线程释放对锁的占有

2.线程执行发生异常，此时JVM会让线程自动释放锁

那么如果这个获取锁的线程由于要等待IO或者其他原因被阻塞了，但是又没有释放锁，其他线程便只能等待，将影响程序执行效率，so，需要一种机制可以不让等待的线程一直无期限等待下去（比如只等待一定的时间或者能够响应中断），Lock就可以

二，java.util.concurrent.locks包下常用的类

1.Lock

从源码可知，Lock是一个接口

public interface Lock {
//	获取锁，如果锁已被其他线程获取，则进行等待
	void lock();
/*
 * lockInterruptibly方法获取锁时，如果线程正在等待获取锁，则这个线程能够响应中断，即中断线程的等待状态
 * 当两个线程同时通过该方法 想获取某个锁，假若此时线程A获取了锁，线程B只有等待，对线程B调用threadB.interrupt()方法能中断线程B的等待
 */
	void lockInterruptibly() throws InterruptedException;
//	尝试获取锁，如果获取成功则返回true，失败（即锁被其他线程获取）则返回false
//	该方法无论如何会立即返回，在拿不到锁时不会一直等待
	boolean tryLock();
//	超时的获取锁，当前线程在以下3种情况会返回：1.当前线程在超时时间内获得了锁2.当前线程在超时时间内被中断3.超时时间结束，返回false
	boolean tryLock(long time,TimeUnit unit) throws InterruptedException;
	//释放锁
	void unlock();
	//获取等待通知组件，该组件和当前的锁绑定，当前线程只有获得了锁，才能调用该组件的wait方法，而调用后，当前线程将释放锁
	Condition newCondition();
}

通常lock的使用方法

        Lock lock=...;
	lock.lock();
	try{
//		处理任务
	}catch(Exception ex){
		
	}finally{
		lock.unlock();//释放锁
	}

tryLock的通常使用

	Lock lock=...;
	if(lock.tryLock()){
		try{
//			处理任务
		}catch(Exception ex){
			
		}finally{
			lock.unlock();//释放锁
		}
	}else{
//		如果不能获取锁，则直接做其他事情
	}

lockInterruptibly()必须放在try块中或者声明抛出异常

	Lock lock=...;
	public void method() throws InterruptedException{
		lock.lockInterruptibly();
		try{
			
		}finally{
			lock.unlock();
		}
	}

通过Lock接口的Condition newCondition()可以生成一个与当前重入锁绑定的Condition实例，利用Condition对象，我们就可以让线程在何时的时间等待，或者在某一个特定的时刻得到通知，继续执行

Condition是一个接口，提供的基本方法如下：

import java.util.Date;
import java.util.concurrent.TimeUnit;

public interface Condition {
//	使当前线程等待，同时释放当前锁，当其他线程中使用signal或signalAll方法时，线程会重新获得锁并继续执行
//	或者当线程被中断时，也能跳出等待
	 void await() throws InterruptedException;
//	 和await方法基本相同，但并不会在等待过程中响应中断
	 void awaitUninterruptibly();
	 long awaitNanos(long nanosTimeout) throws InterruptedException;
	 boolean await(long time, TimeUnit unit) throws InterruptedException;
	 boolean awaitUntil(Date deadline) throws InterruptedException;
	 void signal();//唤醒一个在等待中的线程
	 void signalAll();//唤醒所有在等待中的线程
}

一个例子

package LockTest;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class LockCondition implements Runnable {
	public static ReentrantLock lock=new ReentrantLock();
//	通过lock生成一个与之绑定的condition对象
	public static Condition condition=lock.newCondition();
	public void run(){
		try{
			lock.lock();
			condition.await();//线程在condition对象上进行等待
			System.out.println("Thread is going on");
		}catch(InterruptedException e){
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}

	public static void main(String[] args) throws InterruptedException {
		// TODO Auto-generated method stub
		LockCondition lc=new LockCondition();
		Thread t1=new Thread(lc);
		t1.start();
		Thread.sleep(2000);
//		主线程main发出通知，告诉等待在condition上的线程可以继续执行了
		lock.lock();
		condition.signal();
		lock.unlock();
	}

}

2.ReentrantLock

即可重入锁，实现了Lock接口，并且提供了更多的方法

//	true表示公平锁，false表示非公平锁
	private Lock lock=new ReentrantLock();
	public void out3(String str){
		lock.lock();//如果有其他线程已经获取锁，那么当前线程在此等待直到其他线程释放锁
		try{
			for(int i=0;i<str.length();i++){
				System.out.println(str.charAt(i));
			}
			System.out.println();
		}finally{
//			释放锁资源，之所以加入try代码块，是为了保证锁资源的释放
//			如果代码发生异常也可以保证锁资源的释放，否则其他线程无法拿到锁资源执行业务逻辑，永远处于等待状态
			lock.unlock();
		}
	}

就重入锁的实现来看，它主要集中在java层面，在重入锁的实现中，主要包含三个要素：

第一，是原子状态，原子状态使用CAS操作来存储当前锁的状态，判断是否已经被别的线程持有

第二，是等待队列，所有没有请求到锁的线程，会进入等待队列进行等待，待有线程释放锁后，系统就能从等待队列中唤醒一个线程继续工作

第三，是阻塞原语park()和unpark()，用来挂起和恢复线程，没有得到锁的线程将会被挂起

3.ReadWriteLock

ReadWriteLock也是一个接口，在它里面只定义了两个方法

public interface ReadWriteLock {
    /**
     * Returns the lock used for reading.
     *
     * @return the lock used for reading
     */
    Lock readLock();

    /**
     * Returns the lock used for writing.
     *
     * @return the lock used for writing
     */
    Lock writeLock();
}

4.ReentrantReadWriteLock

接口ReadWriteLock的一个实现类，提供了很多丰富的方法，最主要的两个:readLock()和writeLock()用来获取读锁和写锁，假如有多个线程要同时进行读操作的话，先看synchronized代码

package LockTest;

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class lockTest {
	private ReentrantReadWriteLock rw=new ReentrantReadWriteLock();
	public static void main(String []args){
		final lockTest test=new lockTest();
		new Thread(){
			public void run(){
				test.get(Thread.currentThread());
			};
		}.start();
		
		new Thread(){
			public void run(){
				test.get(Thread.currentThread());
			};
		}.start();
	}
	
	public synchronized void get(Thread thread){
		long start=System.currentTimeMillis();
		while(System.currentTimeMillis()-start<=1){
			System.out.println(thread.getName()+"正在进行读操作");
		}
		System.out.println(thread.getName()+"读操作完毕");
	}
}

运行结果截图，即直到第一个线程执行完读操作后，才会打印第二个线程执行读操作的信息

Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0读操作完毕
Thread-1正在进行读操作
Thread-1正在进行读操作

将上述方法改为读写锁

public void get(Thread thread){
		rw.readLock().lock();
		try{
			long start=System.currentTimeMillis();
			while(System.currentTimeMillis()-start<=1){
				System.out.println(thread.getName()+"正在进行读操作");
			}
			System.out.println(thread.getName()+"读操作完毕");
		}finally{
			rw.readLock().unlock();
		}	
	}

运行结果截图，可见两个线程是同时进行读操作的，这样就大大提升了读操作的效率

Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作

注意：如果有一个线程已经占用了读锁，此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁；如果一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，会一直等待释放写锁

5.提一下信号量Semaphore，允许多个线程同时访问

广义上说，信号量是对锁的扩展，无论是内部锁synchronized还是可重入锁ReentrantLock，一次都只允许一个线程访问一个资源，信号量却是可以指定对个线程，同时访问某一个资源

简单例子，同时开启20个线程，观察输出发现，系统以5个线程为一组，依次输出带有线程ID的提示文本

package LockTest;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class SemapDemo implements Runnable {
	final Semaphore semp=new Semaphore(5);
	public void run(){
		try{
			semp.acquire();
//			模拟耗时操作
			Thread.sleep(2000);
			System.out.println(Thread.currentThread().getId()+":done");
			semp.release();//用acquire申请信号量，离开时，务必使用release释放
		}catch(InterruptedException e){
			e.printStackTrace();
		}
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ExecutorService exec=Executors.newFixedThreadPool(20);
		final SemapDemo demo=new SemapDemo();
		for(int i=0;i<20;i++){
			exec.submit(demo);
		}
	}

}

6.Lock和synchronized的选择

（1）Lock是一个接口，而synchronized是java中的关键字，synchronized是内置的语言实现

（2）synchronized在发生异常时会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock（）去释放锁，则很可能造成死锁现象

（3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断

（4）通过Lock可以知道有没有成功获取锁

（5）Lock可以提高多个线程进行读操作的效率

（6）synchronized中的锁是非公平的，ReentrantLock默认也是非公平的，但可以通过带布尔值的构造函数要求使用公平锁

从性能上说，如果竞争资源不激烈，两者是差不多的，而当竞争资源非常激烈（即有大量线程同时竞争），此时Lock的性能远远优于synchronized

参考：http://www.cnblogs.com/dolphin0520/p/3923167.html