Lock
之前对于synchronized的实现和运用有所了解，但是也发现了一些缺陷，由于synchronized是在JVM层面上实现同步互斥，是以关键字形式加锁，导致其颗粒度过大，有的时候不需要这么大范围的加锁，在中断和线程阻塞处理上也有所欠缺，在JDK1.5之后，Java引入了Lock，作为对于synchronized的补充。
实现原理
Lock是Java的一个接口类，而继承它实现的也是一个Java类，因此Lock的实现不是基于JVM的，而是在应用层，接口源码如下
public interface Lock {
void lock();
void lockInterruptibly() throws InterruptedException;
boolean tryLock();
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
void unlock();
Condition newCondition();
} 这几个方法就是Lock的核心实现。而Lock的实现类是ReentrantLock，这里需要讲一下ReentrantLock的结构，ReentrantLock把对Lock的实现交给了继承AbstractQueuedSynchronizer抽象类的Sync类，而为了实现公平锁和和非公平锁，又加入了FairSync和NonfairSync两个继承Sync的类来重写lock()方法。
- abstract static class Sync extends AbstractQueuedSynchronizer
- static final class NonfairSync extends Sync
- static final class FairSync extends Sync
而ReentrantLock的加锁解锁原理则是利用AbstractQueuedSynchronizer类的方法，把所有的请求线程构成一个CLH队列(虚拟队列，将每个线程内容包装成一个Node类)，运行线程不包括在内，如果有新进程加入，则阻塞并加入到队列尾部，如果运行线程结束，就从队列中获取下个线程。
在了解加锁和解锁过程之前首先需要了解Lock怎么阻塞线程，源码中显示调用了LockSupport.park()，在深入结果是调用sun.misc.Unsafe.park()本地方法，从而调用系统互斥锁。下面就是加锁和解锁的过程
加锁
对于加锁过程，非公平锁和公平锁机制不同，这里分开描述。 非公平锁
在开始就先尝试当前线程获取锁，如果成功，那么直接将锁锁定，不成功再进入队列调用的流程。 进入队列调用的第一步是获取当前锁的状态，如果锁状态值为0，尝试获取锁，如果成功的话，将锁赋给当前线程，失败就阻塞后进入队列尾部排队。
如果锁状态值为1，先看是否为存在重入锁的情况，即线程和运行线程相同，如果是，那么锁状态加1，如果不是，那么阻塞后进入队列尾部排队。
//ReentrantLock.java文件
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();//获取当前线程
int c = getState();//获取锁状态值
if (c == 0) { //如果锁状态为0，那么没有线程占用锁
if (compareAndSetState(0, acquires)) {//CAS尝试获得锁
setExclusiveOwnerThread(current);
return true;
}
}
//如果锁状态不为0
else if (current == getExclusiveOwnerThread()) {//如果当前线程就是锁的线程，进入重入锁状态
int nextc = c + acquires;//锁状态值加1
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
//AbstractQueuedSynchronizer.java文件
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
} 公平锁
不尝试获取锁，直接进入队列流程 在队列流程中，同样获取锁的状态值，如果状态值为0，并且队列中没有排队的线程，那么尝试获取锁，如果有线程，那么就阻塞线程并放在队列尾部排队
如果状态值不为0，先看是否为存在重入锁的情况，即线程和运行线程相同，如果是，那么锁状态加1，如果不是，那么阻塞后进入队列尾部排队。
//ReentrantLock.java文件
final void lock() {
acquire(1);
}
/**
* Fair version of tryAcquire. Don't grant access unless
* recursive call or no waiters or is first.
*/
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
//如果锁状态值为0和队列中没有线程，获取锁
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
//重入锁情况
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
//AbstractQueuedSynchronizer.java文件
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
} 解锁
获取当前线程的状态值，然后减1如果结果为0，那么释放这个锁，如果不为0，那么存在重入锁情况，不释放锁
//ReentrantLock.java文件
public void unlock() {
sync.release(1);
}
protected final boolean tryRelease(int releases) {
//状态值-1
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
//判断重入锁情况
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
//AbstractQueuedSynchronizer.java文件
public final boolean release(int arg) {
if (tryRelease(arg)) {
//获取排队线程的头线程，运行线程
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
} Lock应用
Lock接口有lock()、unlock()、tryLock()、tryLock(long time, TimeUnit unit) 和 lockInterruptibly()这些方法进行加锁和解锁，这里逐个分析（Condition()用于线程间通信，这里暂时不解释）
lock()和unlock()
这两个方法基本都是一起出现的，因为这里放在一起讲，lock()就是用来对代码块进行加锁，而unlock()是对锁的释放，而在它们之间就是加锁的代码，一般会加上try...catch方式，而unlock()一般会出现在finally中，基本格式如下
Lock lock = new Lock();
lock.lock();
try{
//加锁代码块
...
}catch(Exception e){
}finally{
lock.unlock(); //释放锁
} tryLock()和tryLock(long time, TimeUnit unit)
tryLock()是有返回值的，如果当前锁未被占用，那么就尝试获取锁，这里和lock()一样，并返回true，但是如果锁被占用，那么直接返回false，不阻塞在那里，这是和synchronized区别部分之一，是对加锁的灵活运用。 tryLock(long time, TimeUnit unit)是加上了等待时间，就是在tryLock()基础上加上了尝试获取的等待时间，如果锁获取失败，会等待一段时间，如果等待过程中获取到锁，那么返回true，如果还是没有，那么返回false。一般格式如下
Lock lock = new Lock();
if(lock.tryLock()) {
try{
//加锁代码块
...
}catch(Exception e){
}finally{
lock.unlock();
}
}else {
//不加锁的处理
...
} lockInterruptibly()
lockInterruptibly()和lock()的机制是一样的，如果没有特殊情况，就是一般的加锁，但是如果在加锁后使用Thread.interrupt中断线程，就会抛异常InterruptedException，因为lock优先考虑获取锁，在等待获取锁的过程中，忽略中断请求，只有成功获得锁之后才响应中断。lockInterruptibly允许在等待获取锁的过程中由其它线程调用等待线程的Thread.interrupt方法来中断等待线程的等待而直接返回。
Lock lock = new Lock();
lock.lockInterruptibly();
try{
//加锁代码块
...
}catch(InterruptedException e){
}finally{
lock.unlock(); //释放锁
}