1 synchronized的缺陷

synchronized是java中的一个关键字，也就是说是Java语言内置的特性。那么为什么会出现Lock呢？
在上面一篇文章中，我们了解到如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况：
1）获取锁的线程执行完了该代码块，然后线程释放对锁的占有；
2）线程执行发生异常，此时JVM会让线程自动释放锁。
那么如果这个获取锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，其他线程便只能干巴巴地等待，试想一下，这多么影响程序执行效率。
因此就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只等待一定的时间或者能够响应中断），通过Lock就可以办到。
再举个例子：当有多个线程读写文件时，读操作和写操作会发生冲突现象，写操作和写操作会发生冲突现象，但是读操作和读操作不会发生冲突现象。
但是采用synchronized关键字来实现同步的话，就会导致一个问题：
如果多个线程都只是进行读操作，所以当一个线程在进行读操作时，其他线程只能等待无法进行读操作。
因此就需要一种机制来使得多个线程都只是进行读操作时，线程之间不会发生冲突，通过Lock就可以办到。
另外，通过Lock可以知道线程有没有成功获取到锁。这个是synchronized无法办到的。
总结一下，也就是说Lock提供了比synchronized更多的功能。但是要注意以下几点：
1）Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问；
2）Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。

2 Lock

2.1 ReentrantLock
  1. public class LockTest {
  2.     public static void main(String[] args) {
  3.         new LockTest().init();
  4.     }
  5.     private void init() {
  6.         final Outputer outputer = new Outputer();
  7.         new Thread(new Runnable() {
  8.             @Override
  9.             public void run() {
  10.                 while (true) {
  11.                     try {
  12.                         Thread.sleep(10);
  13.                     } catch (InterruptedException e) {
  14.                         e.printStackTrace();
  15.                     }
  16.                     outputer.output("kpioneer");
  17.                 }
  18.             }
  19.         }).start();
  20.         new Thread(new Runnable() {
  21.             @Override
  22.             public void run() {
  23.                 while (true) {
  24.                     try {
  25.                         Thread.sleep(10);
  26.                     } catch (InterruptedException e) {
  27.                         e.printStackTrace();
  28.                     }
  29.                     outputer.output("Jack");
  30.                 }
  31.             }
  32.         }).start();
  33.     }
  34.     static class Outputer {
  36.         Lock lock = new ReentrantLock();
  37.         public void output(String name) {
  38.             int len = name.length();
  39.             lock.lock();
  40.             /**
  41.              *
  42.              *不管程序运行是否异常都要释放锁
  43.              * 否则再也进入不到改页面
  44.              */
  45.             try {
  46.                 for (int i = 0; i < len; i++) {
  47.                     System.out.print(name.charAt(i));
  48.                 }
  49.                 System.out.println();
  50.             } finally {
  51.                 lock.unlock();
  52.             }
  53.         }
  54.     }
  55. }
  1. kpioneer
  2. Jack
  3. kpioneer
  4. Jack
  5. kpioneer
  6. Jack
  7. Jack
  8. kpioneer
  9. Jack
  10. kpioneer
  11. 省略...

2.2 ReentrantReadWriteLock

实中有这样一种场景：对共享资源有读和写的操作，且写操作没有读操作那么频繁。在没有写操作的时候，多个线程同时读一个资源没有任何问题，所以应该允许多个线程同时读取共享资源；但是如果一个线程想去写这些共享资源，就不应该允许其他线程对该资源进行读和写的操作了。
针对这种场景，JAVA的并发包提供了读写锁ReentrantReadWriteLock，它表示两个锁，一个是读操作相关的锁，称为共享锁；一个是写相关的锁，称为排他锁，描述如下：
线程进入读锁的前提条件：
没有其他线程的写锁，
没有写请求或者有写请求，但调用线程和持有锁的线程是同一个。
线程进入写锁的前提条件：
没有其他线程的读锁
没有其他线程的写锁
而读写锁有以下三个重要的特性：
（1）公平选择性：支持非公平（默认）和公平的锁获取方式，吞吐量还是非公平优于公平。
（2）重进入：读锁和写锁都支持线程重进入。
（3）锁降级：遵循获取写锁、获取读锁再释放写锁的次序，写锁能够降级成为读锁。

  1. public class ReadWriteLockTest {
  2.     public static void main(String[] args) {
  3.         final Queue q = new Queue();
  4.         for (int i = 0; i < 3; i++) {
  5.             new Thread() {
  6.                 @Override
  7.                 public void run() {
  8.                     while (true) {
  9.                         q.get();
  10.                     }
  11.                 }
  12.             }.start();
  13.             new Thread() {
  14.                 @Override
  15.                 public void run() {
  16.                     while (true) {
  17.                         q.put(new Random().nextInt(10000));
  18.                     }
  19.                 }
  20.             }.start();
  21.         }
  22.     }
  23. }
  24. class Queue {
  25.     //共享数据，只能有一个线程能写该数据，但可以有多个线程同时读该数据。
  26.     ReadWriteLock rwl = new ReentrantReadWriteLock();
  27.     private Object data = null;//共享数据，只能有一个线程能写数据，但可以有多个线程读该数据
  28.     public void get() {
  29.         //上读锁，其他线程只能读不能写
  30.         rwl.readLock().lock();
  31.         try {
  32.             System.out.println(Thread.currentThread().getName() + " be ready to read data!");
  33.             Thread.sleep((long) (Math.random() * 1000));
  34.             System.out.println(Thread.currentThread().getName() + " have read data :" + data);
  35.         } catch (InterruptedException e) {
  36.             e.printStackTrace();
  37.         } finally {
  38.             rwl.readLock().unlock();
  39.         }
  40.     }
  41.     public void put(Object data) {
  42.         //上写锁，不允许其他线程读也不允许写
  43.         rwl.writeLock().lock();
  44.         try {
  45.             System.out.println(Thread.currentThread().getName() + " be ready to write data!");
  46.             Thread.sleep((long) (Math.random() * 1000));
  47.             this.data = data;
  48.             System.out.println(Thread.currentThread().getName() + " have write data: " + data);
  49.         } catch (InterruptedException e) {
  50.             e.printStackTrace();
  51.         } finally {
  52.             rwl.writeLock().unlock();
  53.         }
  54.     }
  55. }
  1. Thread-0 be ready to read data!
  2. Thread-2 be ready to read data!
  3. Thread-2 have read data :null
  4. Thread-0 have read data :null
  5. Thread-1 be ready to write data!
  6. Thread-1 have write data: 4664
  7. Thread-1 be ready to write data!
  8. Thread-1 have write data: 1849
  9. Thread-3 be ready to write data!
  10. Thread-3 have write data: 75
  11. Thread-3 be ready to write data!
  12. Thread-3 have write data: 8222
  13. Thread-3 be ready to write data!
  14. Thread-3 have write data: 3056
  15. Thread-3 be ready to write data!
  16. Thread-3 have write data: 6114
  17. Thread-3 be ready to write data!
  18. Thread-3 have write data: 6376
  19. 省略...

3 锁的相关概念介绍

在前面介绍了Lock的基本使用，这一节来介绍一下与锁相关的几个概念。

3.1 可重入锁

如果锁具备可重入性，则称作为可重入锁。像synchronized和ReentrantLock都是可重入锁，可重入性在我看来实际上表明了锁的分配机制：基于线程的分配，而不是基于方法调用的分配。举个简单的例子，当一个线程执行到某个synchronized方法时，比如说method1，而在method1中会调用另外一个synchronized方法method2，此时线程不必重新去申请锁，而是可以直接执行方法method2。
看下面这段代码就明白了：

  1. class MyClass {
  2.     public synchronized void method1() {
  3.         method2();
  4.     }
  6.     public synchronized void method2() {
  8.     }
  9. }

上述代码中的两个方法method1和method2都用synchronized修饰了，假如某一时刻，线程A执行到了method1，此时线程A获取了这个对象的锁，而由于method2也是synchronized方法，假如synchronized不具备可重入性，此时线程A需要重新申请锁。但是这就会造成一个问题，因为线程A已经持有了该对象的锁，而又在申请获取该对象的锁，这样就会线程A一直等待永远不会获取到的锁。
而由于synchronized和Lock都具备可重入性，所以不会发生上述现象。

3.2 可中断锁

可中断锁：顾名思义，就是可以相应中断的锁。
　　在Java中，synchronized就不是可中断锁，而Lock是可中断锁。
　　如果某一线程A正在执行锁中的代码，另一线程B正在等待获取该锁，可能由于等待时间过长，线程B不想等待了，想先处理其他事情，我们可以让它中断自己或者在别的线程中中断它，这种就是可中断锁。
　　在前面演示lockInterruptibly()的用法时已经体现了Lock的可中断性。

3.3 公平锁

公平锁即尽量以请求锁的顺序来获取锁。比如同是有多个线程在等待一个锁，当这个锁被释放时，等待时间最久的线程（最先请求的线程）会获得该所，这种就是公平锁。
非公平锁即无法保证锁的获取是按照请求锁的顺序进行的。这样就可能导致某个或者一些线程永远获取不到锁。
在Java中，synchronized就是非公平锁，它无法保证等待的线程获取锁的顺序。
而对于ReentrantLock和ReentrantReadWriteLock，它默认情况下是非公平锁，但是可以设置为公平锁。
看一下这2个类的源代码就清楚了：

  1. /**
  2.      * Base of synchronization control for this lock. Subclassed
  3.      * into fair and nonfair versions below. Uses AQS state to
  4.      * represent the number of holds on the lock.
  5.      */
  6.     abstract static class Sync extends AbstractQueuedSynchronizer {
  7.         private static final long serialVersionUID = -5179523762034025860L;
  8.         /**
  9.          * Performs {@link Lock#lock}. The main reason for subclassing
  10.          * is to allow fast path for nonfair version.
  11.          */
  12.         abstract void lock();
  13.         /**
  14.          * Performs non-fair tryLock.  tryAcquire is implemented in
  15.          * subclasses, but both need nonfair try for trylock method.
  16.          */
  17.         final boolean nonfairTryAcquire(int acquires) {
  18.             final Thread current = Thread.currentThread();
  19.             int c = getState();
  20.             if (c == 0) {
  21.                 if (compareAndSetState(0, acquires)) {
  22.                     setExclusiveOwnerThread(current);
  23.                     return true;
  24.                 }
  25.             }
  26.             else if (current == getExclusiveOwnerThread()) {
  27.                 int nextc = c + acquires;
  28.                 if (nextc < 0) // overflow
  29.                     throw new Error("Maximum lock count exceeded");
  30.                 setState(nextc);
  31.                 return true;
  32.             }
  33.             return false;
  34.         }
  35.         protected final boolean tryRelease(int releases) {
  36.             int c = getState() - releases;
  37.             if (Thread.currentThread() != getExclusiveOwnerThread())
  38.                 throw new IllegalMonitorStateException();
  39.             boolean free = false;
  40.             if (c == 0) {
  41.                 free = true;
  42.                 setExclusiveOwnerThread(null);
  43.             }
  44.             setState(c);
  45.             return free;
  46.         }
  47.         protected final boolean isHeldExclusively() {
  48.             // While we must in general read state before owner,
  49.             // we don't need to do so to check if current thread is owner
  50.             return getExclusiveOwnerThread() == Thread.currentThread();
  51.         }
  52.         final ConditionObject newCondition() {
  53.             return new ConditionObject();
  54.         }
  55.         // Methods relayed from outer class
  56.         final Thread getOwner() {
  57.             return getState() == 0 ? null : getExclusiveOwnerThread();
  58.         }
  59.         final int getHoldCount() {
  60.             return isHeldExclusively() ? getState() : 0;
  61.         }
  62.         final boolean isLocked() {
  63.             return getState() != 0;
  64.         }
  65.         /**
  66.          * Reconstitutes the instance from a stream (that is, deserializes it).
  67.          */
  68.         private void readObject(java.io.ObjectInputStream s)
  69.             throws java.io.IOException, ClassNotFoundException {
  70.             s.defaultReadObject();
  71.             setState(0); // reset to unlocked state
  72.         }
  73.     }
  1. /**
  2.      * Sync object for non-fair locks
  3.      */
  4.     static final class NonfairSync extends Sync {
  5.         private static final long serialVersionUID = 7316153563782823691L;
  6.         /**
  7.          * Performs lock.  Try immediate barge, backing up to normal
  8.          * acquire on failure.
  9.          */
  10.         final void lock() {
  11.             if (compareAndSetState(0, 1))
  12.                 setExclusiveOwnerThread(Thread.currentThread());
  13.             else
  14.                 acquire(1);
  15.         }
  16.         protected final boolean tryAcquire(int acquires) {
  17.             return nonfairTryAcquire(acquires);
  18.         }
  19.     }
  20.     /**
  21.      * Sync object for fair locks
  22.      */
  23.     static final class FairSync extends Sync {
  24.         private static final long serialVersionUID = -3000897897090466540L;
  25.         final void lock() {
  26.             acquire(1);
  27.         }
  28.         /**
  29.          * Fair version of tryAcquire.  Don't grant access unless
  30.          * recursive call or no waiters or is first.
  31.          */
  32.         protected final boolean tryAcquire(int acquires) {
  33.             final Thread current = Thread.currentThread();
  34.             int c = getState();
  35.             if (c == 0) {
  36.                 if (!hasQueuedPredecessors() &&
  37.                     compareAndSetState(0, acquires)) {
  38.                     setExclusiveOwnerThread(current);
  39.                     return true;
  40.                 }
  41.             }
  42.             else if (current == getExclusiveOwnerThread()) {
  43.                 int nextc = c + acquires;
  44.                 if (nextc < 0)
  45.                     throw new Error("Maximum lock count exceeded");
  46.                 setState(nextc);
  47.                 return true;
  48.             }
  49.             return false;
  50.         }
  51.     }

另外在ReentrantLock类中定义了很多方法，比如：
isFair() //判断锁是否是公平锁
isLocked() //判断锁是否被任何线程获取了
isHeldByCurrentThread() //判断锁是否被当前线程获取了
hasQueuedThreads() //判断是否有线程在等待该锁
在ReentrantReadWriteLock中也有类似的方法，同样也可以设置为公平锁和非公平锁。不过要记住，ReentrantReadWriteLock并未实现Lock接口，它实现的是ReadWriteLock接口。

3.4 读写锁

读写锁将对一个资源（比如文件）的访问分成了2个锁，一个读锁和一个写锁。
正因为有了读写锁，才使得多个线程之间的读操作不会发生冲突。
ReadWriteLock就是读写锁，它是一个接口，ReentrantReadWriteLock实现了这个接口。
可以通过readLock()获取读锁，通过writeLock()获取写锁。

  1. public class CacheDemo {
  2.     private Map<String, Object> cache = new HashMap<>();
  3.     private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
  4.     public static void main(String[] args) {
  5.     }
  6.     public Object getData(String key) {
  7.         Object value = null;
  8.         //首先开启读锁，从缓存中去取
  9.         readWriteLock.readLock().lock();
  10.         try {
  11.             value = cache.get(key);
  12.             //如果缓存中没有释放读锁，上写锁
  13.             if (value == null) {
  14.                 //对应queryDB()
  15.                 readWriteLock.readLock().unlock();
  16.                 //读锁必须unlock之后才能获取写锁
  17.                 readWriteLock.writeLock().lock();
  18.                 try {
  19.                     //对应queryDB()
  20.                     value = queryDB();
  21.                 } finally {
  22.                     //释放写锁
  23.                     readWriteLock.writeLock().unlock();
  24.                 }
  25.                 //然后再上读锁
  26.                 readWriteLock.readLock().lock();
  27.             }
  28.         } finally {
  29.             //最后释放读锁
  30.             readWriteLock.readLock().unlock();
  31.         }
  32.         return value;
  33.     }
  34.     public Object queryDB() {
  35.         return "aaaa";
  36.     }
  37. }

转：https://www.jianshu.com/p/2c0aaee7d9b4