大体来说Lock、ReentrantLock与Synchronized很相似，对对象加锁
首先是Lock接口：
public interface Lock {
void lock();
void lockInterruptibly() throws InterruptedException;
boolean tryLock();
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
void unlock();
Condition newCondition();
}
lock()上锁、unlock()解锁、
trylock()获取锁，若被其它线程获取则返回，这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待会直接返回false。
tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，再返回false。如果如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。
lockInterruptibly()方法获取某个锁时，如果不能获取到，只有进行等待的情况下，是可以响应中断的。而用synchronized修饰的话，当一个线程处于等待某个锁的状态，是无法被中断的，只有一直等待下去。
ReentrantLock是Lock接口的一个实现类，ReentrantLock自然包含Lock的所有功能：
/**
* Created by qiaorenjie on 2018/3/23.
*/
public class LockTest {
public static void main(String[] args) {
final Phone phone = new Phone();
new Thread(new Runnable() {
@Override
public void run() {
while (true){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
phone.getPhone("iphone-x plus");
}
}
}).start();
new Thread(){
@Override
public void run() {
while (true){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
phone.getPhone("小米特别版");
}
}
}.start();
}
static class Phone {
Lock lock = new ReentrantLock();
public void getPhone(String phone){
int len = phone.length();
lock.lock(); // 开始加锁
try {
for (int i=0; i<len;i++){
System.out.print(phone.charAt(i));
}
System.out.println("---------");
}finally {
lock.unlock(); // 释放锁
}
}
public synchronized void getPhone2(String phone){
for (int i=0; i<phone.length();i++){
System.out.print(phone.charAt(i));
}
System.out.println("---------");
}
public static synchronized void getPhone3(String phone){
for (int i=0; i<phone.length();i++){
System.out.print(phone.charAt(i));
}
System.out.println("---------");
}
}
}
这是Lock的ReentrantLock一个典型应用。ReentantLock 继承接口 Lock，他是一种可重入锁，除了能完成 synchronized 所能完成的所有工作外，还提供了诸如可响应中断锁、可轮询锁请求、定时锁等避免多线程死锁的方法。
接下来是Lock下的读写锁：读写锁，分为读锁和写锁，多个读锁间不互斥，但凡涉及到写锁就要互斥。如果代码允许很多人同时读，但不能同时写，那就上读锁；如果修改代码数据，同时只能一个人修改，且不能同时读取，那就要上读写锁。jvm会自动完成操作。
ReadWriteLock源码如下：
public interface ReadWriteLock {
Lock readLock();
Lock writeLock();
}
可见ReadWriteLock接口只有读锁和写锁两个方法，通过ReentrantReadWriteLock实现(意外发现Lock的实现类也是叫Reentrant....所以Reentrant表示这一类都可以重入)
经典应用题：写一个缓存类，对数据进行get，读与写。
/**
* Created by qiaorenjie on 2018/3/30.
*/
public class CacheDemo {
private Map<String,Object> cache = new HashMap<>();
public static void main(String[] args) {
}
private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
public Object getData(String key){
readWriteLock.readLock().lock();
Object value = null; // 让value在try内可见，数据的操作在try里这样总是在finally里unlock
try {
value = cache.get(key);
if (value == null){
readWriteLock.readLock().unlock(); //发现内容为空就要写，释放读锁加写锁不让其他来读
readWriteLock.writeLock().lock(); //不管其他几个线程只要这加了写锁，就不能读了
try {
if(value == null) { // 第一个线程写了第二个线程发现后就不用在写了
value = "aaaaa"; // 假设从数据库queryDB();
}
}finally {
readWriteLock.writeLock().unlock();
}
readWriteLock.readLock().lock(); //回复读锁恢复原状
}
}finally {
readWriteLock.readLock().unlock();
}
return value;
}
}
读的时候发现为空那么此时就要释放读锁加写锁进行写的操作，当加了写锁之后其他线程都不能进行读的操作，只能写，写完后再加读锁保证数据可读恢复原状。假如三个线程，第一个线程写完之后加读锁然后释放，第二个线程读锁再进入，如果写过了就不用再写。
相比直接在方法上加synchronized读写锁更加细粒度，更加有效率。
Synchronized与ReentrantLock：
相同点：
1.ReentrantLock和synchronized都是独占锁,只允许线程互斥的访问临界区。但是实现上两者不同:synchronized加锁解锁的过程是隐式的,用户不用手动操作,优点是操作简单，但显得不够灵活。一般并发场景使用synchronized的就够了；ReentrantLock需要手动加锁和解锁,且解锁的操作尽量要放在finally代码块中,保证线程正确释放锁。ReentrantLock操作较为复杂，但是因为可以手动控制加锁和解锁过程,在复杂的并发场景中能派上用场。
2.ReentrantLock和synchronized都是可重入的。synchronized因为可重入因此可以放在被递归执行的方法上,且不用担心线程最后能否正确释放锁；而ReentrantLock在重入时要却确保重复获取锁的次数必须和重复释放锁的次数一样，否则可能导致其他线程无法获得该锁。
不同点
1.ReentrantLock是Java层面的实现，synchronized是JVM层面的实现。
2.ReentrantLock可以实现公平和非公平锁。
3.ReentantLock获取锁时，限时等待，配合重试机制更好的解决死锁
4.ReentrantLock可响应中断
5.使用synchronized结合Object上的wait和notify方法可以实现线程间的等待通知机制。ReentrantLock结合Condition接口同样可以实现这个功能。而且相比前者使用起来更清晰也更简单。
ReentrantLock详解
ReetrantLock实现依赖于AQS(AbstractQueuedSynchronizer)，主要依靠AQS维护一个阻塞队列，多个线程加锁时，失败则会进入阻塞队列。等待唤醒，重新尝试加锁。ReentrantLock源码：
从源码里可以看到，ReentrantLock继承了Lock接口， lock方法实际上是调用了Sync的子类NonfairSync(非公平锁)的lock方法。ReentrantLock的真正实现在他的两个内部类NonfairSync 和 FairSync中，并且内部类都继承于内部类Sync，而Sync根本的实现则是AbstractQueuedSynchronizer抽象队列同步器（AQS）。AQS很重要下一章专门将。
公平锁与非公平锁：
ReentrantLock除了和Sychronized一样支持重入之外，还支持公平锁和非公平锁。
公平锁：多个线程申请获得同一资源的时候，必须按照先来后到顺序依次公平地获得。
非公平锁：资源释放时任何线程都有机会抢到资源，大家一起上，容易引发“恶狼效应”。
其中：
ReentrantLock()：默认非公平锁
ReentrantLock(boolean fair)：配置公平锁/非公平锁（false：非公平锁；true：公平锁）
公平锁的实现原理：
/** Sync object for fair locks */
static final class FairSync extends Sync {
private static final long serialVersionUID = -3000897897090466540L;
final void lock() {
acquire(1);
}
/** Fair version of tryAcquire... */
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 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;
}
}
从源码中FairSync继承Sync，而Sync继承AbstractQueuedSynchronizer。ReentrantLock调用lock方法，最终会调用sync的tryAcquire函数，获取资源。FairSync的tryAcquire函数，当前线程只有在队列为空或者时队首节点的时候，才能获取资源，否则会被加入到阻塞队列中，这里实现了公平的机制。下面的hasQueuedPredecessors函数用于判断队列是否为空，或者当前元素是否为队首元素。
public final boolean hasQueuedPredecessors() {
Node t = tail; // Read fields in reverse initialization order
Node h = head;
Node s;
return h != t &&
((s = h.next) == null || s.thread != Thread.currentThread());
}
hasQueuedPredecessors函数，如果h==t(队列为空)，或者h!=t && s.thread == Thread.currentThread()(队首节点)，则返回false，否则返回true。
非公平锁实现原理：
/** Sync object for non-fair locks */
static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;
/** Performs lock. Try immediate barge...*/
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) {
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
NoFairSync同样继承Sync，ReentrantLock调用lock方法，最终会调用sync的tryAcquire函数，获取资源。而NoFairSync的tryAcquire函数，会调用父类Sync的方法nofairTryAcquire函数。通过对比可以发现，如果资源释放时，新的线程会尝试CAS操作获取资源，而不管阻塞队列中是否已经有其它申请的线程。
下一章重点讲解AQS。
