Lock(concurrent包)
Java并发编程：Lock - Matrix海子 - 博客园
为什么需要使用Lock
Lock是一个接口，Lock和synchornized一样属于悲观锁
synchornized的缺点
- 如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况：
1）获取锁的线程执行完了该代码块，然后线程释放对锁的占有；
2）线程执行发生异常，此时JVM会让线程自动释放锁。
那么如果这个获取锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，其他线程便只能干巴巴地等待，试想一下，这多么影响程序执行效率。
因此就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只等待一定的时间或者能够响应中断），通过Lock就可以办到。
如果多个线程都只是进行读操作，所以当一个线程在进行读操作时，其他线程只能等待无法进行读操作。
因此就需要一种机制来使得多个线程都只是进行读操作时，线程之间不会发生冲突，通过Lock就可以办到。
另外，通过Lock可以知道线程有没有成功获取到锁。这个是synchronized无法办到的。
总结不同点
总结一下，也就是说Lock提供了比synchronized更多的功能。但是要注意以下几点：
1）Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问；
2）Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。
Lock接口的方法及使用
public interface Lock {
void lock();
void lockInterruptibly() throws InterruptedException;
boolean tryLock();
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
void unlock();
Condition newCondition();
}1. lock()方法
首先lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。
由于在前面讲到如果采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。
Lock lock = ...;
lock.lock();
try{
//处理任务
}catch(Exception ex){
}finally{
lock.unlock(); //释放锁
}2. tryLock()方法
tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。
tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。
所以，一般情况下通过tryLock来获取锁时是这样使用的：
Lock lock = ...;
if(lock.tryLock()) {
try{
//处理任务
}catch(Exception ex){
}finally{
lock.unlock(); //释放锁
}
}else {
//如果不能获取锁，则直接做其他事情
}3. lockInterruptibly()方法
lockInterruptibly() 是 Java 并发包 java.util.concurrent.locks.Lock 接口中的一个方法。
它的核心作用是：获取锁，但是允许被“打断”。
为了理解它，我们得先对比一下最常用的 synchronized 和 Lock.lock()。
1. 痛点：死等（不可中断）
假设你有一个线程 A 正在等待一把锁（被线程 B 拿着）。
- 使用 synchronized：
线程 A 会进入“死等”状态。不管你在这个时候对线程 A 调用 threadA.interrupt() 多少次，线程 A 根本不理你，它会一直等到死，或者等到拿到锁为止。它无法响应中断。
- 使用 Lock.lock()：
大部分情况下，它和 synchronized 一样。如果拿不到锁，它就在那等着，虽然实现不同，但行为上也是“死等”，不立刻响应中断（通常是在获取到锁之后才检查中断标志）。
2. lockInterruptibly() 的解决方案
lockInterruptibly() 就是为了解决“死等”问题而生的。
用法逻辑：
尝试拿锁：如果锁没人用，我拿走，办事。
等待：如果锁被别人拿着，我开始排队等待。
被中断：重点来了。在等待的过程中，如果其他线程调用了我的 interrupt() 方法：
我不再等待锁了。
我直接抛出一个 InterruptedException 异常。
我从等待队列里“醒”过来，去处理这个异常（比如清理资源、记录日志、退出）。
因此lockInterruptibly()一般的使用形式如下：
public void method() throws InterruptedException {
lock.lockInterruptibly();
try {
//.....
}
finally {
lock.unlock();
}
}ReentranLock(实现了Lock接口)
ReentrantLock，意思是“可重入锁”,ReentrantLock是唯一实现了Lock接口的类，并且ReentrantLock提供了更多的方法。
需要把ReentranLock设置成静态变量，保证不同的线程都是使用的同一个ReentranLock
读写锁(ReadWriteLock)和Lock一样，也是一个接口
接口定义：
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();
}一个用来获取读锁，一个用来获取写锁。也就是说将文件的读写操作分开，分成2个锁来分配给线程，从而使得多个线程可以同时进行读操作。下面的ReentrantReadWriteLock实现了ReadWriteLock接口。
ReentrantReadWriteLock
ReentrantReadWriteLock里面提供了很多丰富的方法，不过最主要的有两个方法：readLock()和writeLock()用来获取读锁和写锁。
读锁允许线程并发访问，写锁不允许线程并发访问，需要等读锁或写锁释放之后才能访问
Lock和synchornized的选择
总结来说，Lock和synchronized有以下几点不同：
1）Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；
2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；
3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；
4）通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。
5）Lock可以提高多个线程进行读操作的效率。
在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。
synchornized和Lock的性质
synchornized和Lock都是可重入锁；
synchornized不可中断，Lock可中断；
synchornized和Lock默认都是非公平锁，Lock可设置为公平；