上一篇中说过了synchronized和它的应用范畴，看起来曾经能够解决所有状况了，那为什么还须要Lock呢？
Lock和synchronized
上篇中说到，被synchronized润饰的代码块只能由获取锁的线程执行，在开释锁之前，其余线程只能期待，这样就很影响效率，比方，一份文件不能同时写，然而容许同时读，这种状况synchronized就无奈实现，此时须要一个机制使多个线程能够同时执行读操作。
留神：Lock须要手动去开释，如果在执行完没有开释锁，就有可能造成死锁景象，synchronized不须要用户去手动开释锁，当synchronized办法或者synchronized代码块执行完之后，零碎会主动让线程开释对锁的占用。
可重入锁
可重入锁，可重入就是说某个线程曾经取得某个锁，能够再次获取锁而不会呈现死锁，可重入锁有以下两种：
- synchronized
- ReentrantLock
synchronized
public class ReentrantLockDemo { public static void main(String[] args) { new Thread(new Runnable() { @Override public void run() { synchronized (this) { System.out.println("第1次获取锁，这个锁是：" + this); int index = 1; while (true) { synchronized (this) { System.out.println("第" + (++index) + "次获取锁，这个锁是：" + this); } if (index == 10) { break; } } } } }).start(); }}运行后果
每次获取的都是同一个锁
第1次获取锁，这个锁是：com.example.offer.thread.lock.ReentrantLockDemo$1@3cc49e81第2次获取锁，这个锁是：com.example.offer.thread.lock.ReentrantLockDemo$1@3cc49e81第3次获取锁，这个锁是：com.example.offer.thread.lock.ReentrantLockDemo$1@3cc49e81第4次获取锁，这个锁是：com.example.offer.thread.lock.ReentrantLockDemo$1@3cc49e81第5次获取锁，这个锁是：com.example.offer.thread.lock.ReentrantLockDemo$1@3cc49e81第6次获取锁，这个锁是：com.example.offer.thread.lock.ReentrantLockDemo$1@3cc49e81第7次获取锁，这个锁是：com.example.offer.thread.lock.ReentrantLockDemo$1@3cc49e81第8次获取锁，这个锁是：com.example.offer.thread.lock.ReentrantLockDemo$1@3cc49e81第9次获取锁，这个锁是：com.example.offer.thread.lock.ReentrantLockDemo$1@3cc49e81第10次获取锁，这个锁是：com.example.offer.thread.lock.ReentrantLockDemo$1@3cc49e81ReentrantLock锁定和开释次数雷同
public class ReentrantLockDemo2 { public static void main(String[] args) { ReentrantLock lock = new ReentrantLock(); new Thread(new Runnable() { @Override public void run() { try { lock.lock(); System.out.println("线程1第1次获取锁，这个锁是：" + lock); int index = 1; while (true) { try { lock.lock(); System.out.println("线程1第" + (++index) + "次获取锁，这个锁是：" + lock); if (index == 10) { break; } } finally { //ReentrantLock不会主动开释，须要手动开释锁，否则会有死锁问题 lock.unlock(); } } } finally { lock.unlock(); } } }).start(); new Thread(new Runnable() { @Override public void run() { try { lock.lock(); System.out.println("线程2第1次获取锁，这个锁是：" + lock); } finally { lock.unlock(); } } }).start(); }}运行后果
每次获取的都是同一个锁
线程1第1次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@32c3e0c4[Locked by thread Thread-0]线程1第2次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@32c3e0c4[Locked by thread Thread-0]线程1第3次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@32c3e0c4[Locked by thread Thread-0]线程1第4次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@32c3e0c4[Locked by thread Thread-0]线程1第5次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@32c3e0c4[Locked by thread Thread-0]线程1第6次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@32c3e0c4[Locked by thread Thread-0]线程1第7次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@32c3e0c4[Locked by thread Thread-0]线程1第8次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@32c3e0c4[Locked by thread Thread-0]线程1第9次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@32c3e0c4[Locked by thread Thread-0]线程1第10次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@32c3e0c4[Locked by thread Thread-0]线程2第1次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@32c3e0c4[Locked by thread Thread-1]ReentrantLock锁定和开释次数不同
public class ReentrantLockDemo3 { public static void main(String[] args) { ReentrantLock lock = new ReentrantLock(); new Thread(new Runnable() { @Override public void run() { try { lock.lock(); System.out.println("线程1第1次获取锁，这个锁是：" + lock); int index = 1; while (true) { try { lock.lock(); System.out.println("线程1第" + (++index) + "次获取锁，这个锁是：" + lock); if (index == 10) { break; } } finally { //ReentrantLock不会主动开释，须要手动开释锁，否则会有死锁问题，比方此时加锁次数大于解锁次数 if (index < 8) { lock.unlock(); } } } } finally { lock.unlock(); } } }).start(); new Thread(new Runnable() { @Override public void run() { try { lock.lock(); System.out.println("线程2第1次获取锁，这个锁是：" + lock); } finally { lock.unlock(); } } }).start(); }}运行后果
每次获取的都是同一个锁，然而因为加锁次数大于解锁次数，所以线程2始终无奈运行
线程1第1次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@72460481[Locked by thread Thread-0]线程1第2次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@72460481[Locked by thread Thread-0]线程1第3次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@72460481[Locked by thread Thread-0]线程1第4次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@72460481[Locked by thread Thread-0]线程1第5次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@72460481[Locked by thread Thread-0]线程1第6次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@72460481[Locked by thread Thread-0]线程1第7次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@72460481[Locked by thread Thread-0]线程1第8次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@72460481[Locked by thread Thread-0]线程1第9次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@72460481[Locked by thread Thread-0]线程1第10次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@72460481[Locked by thread Thread-0]为什么要有可重入锁
public class Demo1 { Demo1 demo1 = new Demo1(); demo1.functionA(); public synchronized void functionA(){ System.out.println("iAmFunctionA"); functionB(); } public synchronized void functionB(){ System.out.println("iAmFunctionB"); }}SynchronizedDemo润饰的是代码块，锁定对象即实例化进去的对象demo1，如果锁定类，那就锁定Demo1
functionA()和functionB()都是同步办法，当线程进入funcitonA()会取得该类的对象锁，这个锁"demo1"，在functionA()对办法functionB()做了调用，然而functionB()也是同步的，因而该线程须要再次取得该对象锁（demo1）。其余线程是无奈获该对象锁的。
可重入锁的作用就是为了防止死锁
ReentrantLock
Lock
Lock，必须被动去开释锁，并且在产生异样时，不会主动开释锁。因而一般来说，应用Lock必须在try{}catch{}块中进行，并且将开释锁的操作放在finally块中进行，以保障锁肯定被被开释，避免死锁的产生。
public class LockDemo { private ArrayList<Integer> arrayList = new ArrayList<Integer>(); Lock lock = new ReentrantLock(); public static void main(String[] args) { final LockDemo lockDemo = new LockDemo(); new Thread() { public void run() { lockDemo.insert(Thread.currentThread()); }; }.start(); new Thread() { public void run() { lockDemo.insert(Thread.currentThread()); }; }.start(); } public void insert(Thread thread) { lock.lock(); try { System.out.println(thread.getName() + "失去了锁"); for (int i = 0; i < 5; i++) { arrayList.add(i); } } catch (Exception e) { // TODO: handle exception } finally { System.out.println(thread.getName() + "开释了锁"); lock.unlock(); } }}运行后果
Thread-0失去了锁Thread-0开释了锁Thread-1失去了锁Thread-1开释了锁tryLock
tryLock()办法有返回值，它示意用来尝试获取锁，如果获取胜利，则返回true，如果获取失败（即锁已被其余线程获取），则返回false，也就说这个办法无论如何都会立刻返回。在拿不到锁时不会始终在那期待。
public class TryLockDemo { private ArrayList<Integer> arrayList = new ArrayList<Integer>(); private Lock lock = new ReentrantLock(); //留神这个中央 public static void main(String[] args) { final TryLockDemo tryLockDemo = new TryLockDemo(); new Thread() { public void run() { tryLockDemo.insert(Thread.currentThread()); }; }.start(); new Thread() { public void run() { tryLockDemo.insert(Thread.currentThread()); }; }.start(); } public void insert(Thread thread) { if (lock.tryLock()) { try { System.out.println(thread.getName() + "失去了锁"); for (int i = 0; i < 5; i++) { arrayList.add(i); } Thread.sleep(100); } catch (Exception e) { // TODO: handle exception } finally { System.out.println(thread.getName() + "开释了锁"); lock.unlock(); } } else { System.out.println(thread.getName() + "获取锁失败"); } }}运行后果
Thread-0失去了锁Thread-1获取锁失败Thread-0开释了锁lockInterruptibly
lockInterruptibly()办法比拟非凡，当通过这个办法去获取锁时，如果线程正在期待获取锁，则这个线程可能响应中断，即中断线程的期待状态。也就使说，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B只有在期待，那么对线程B调用threadB.interrupt()办法可能中断线程B的期待过程。
public class LockInterruptiblyDemo { private Lock lock = new ReentrantLock(); public static void main(String[] args) { LockInterruptiblyDemo test = new LockInterruptiblyDemo(); MyThread thread1 = new MyThread(test); MyThread thread2 = new MyThread(test); thread1.start(); thread2.start(); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } thread2.interrupt(); } public void insert(Thread thread) throws InterruptedException { lock.lockInterruptibly(); try { System.out.println(thread.getName() + "失去了锁"); long startTime = System.currentTimeMillis(); for (; ; ) { if (System.currentTimeMillis() - startTime >= Integer.MAX_VALUE) break; //插入数据 } } finally { System.out.println(Thread.currentThread().getName() + "执行finally"); lock.unlock(); System.out.println(thread.getName() + "开释了锁"); } }}class MyThread extends Thread { private LockInterruptiblyDemo test = null; public MyThread(LockInterruptiblyDemo test) { this.test = test; } @Override public void run() { try { test.insert(Thread.currentThread()); } catch (InterruptedException e) { //中断线程 Thread.currentThread().interrupt(); System.out.println(Thread.currentThread().getName() + "被中断"); } }}ReadWriteLock
ReadWriteLock是一个接口
ReentrantReadWriteLock
ReentrantReadWriteLock中有readLock()和writeLock()用来获取读锁和写锁
public class ReentrantReadWriteLockDemo { private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock(); public static void main(String[] args) { final ReentrantReadWriteLockDemo test = new ReentrantReadWriteLockDemo(); 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) { int index = 0; while (index < 5) { System.out.println(thread.getName() + "正在进行读操作"); index++; } System.out.println(thread.getName() + "读操作结束"); }}运行后果
应用synchronized，一个线程获取到锁后，其余线程无奈读取
Thread-0正在进行读操作Thread-0正在进行读操作Thread-0正在进行读操作Thread-0正在进行读操作Thread-0正在进行读操作Thread-0读操作结束Thread-1正在进行读操作Thread-1正在进行读操作Thread-1正在进行读操作Thread-1正在进行读操作Thread-1正在进行读操作Thread-1读操作结束public class ReentrantReadWriteLockDemo1 { private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock(); public static void main(String[] args) { final ReentrantReadWriteLockDemo1 test = new ReentrantReadWriteLockDemo1(); new Thread() { public void run() { test.get(Thread.currentThread()); } ; }.start(); new Thread() { public void run() { test.get(Thread.currentThread()); } ; }.start(); } public void get(Thread thread) { rwl.readLock().lock(); try { int index = 0; while (index < 5) { System.out.println(thread.getName() + "正在进行读操作"); index++; } } finally { rwl.readLock().unlock(); } }}运行后果
应用ReentrantReadWriteLock，一个线程获取到锁后，其余线程也能够进行操作。
有一个线程曾经占用了读锁，则此时其余线程如果要申请写锁，则申请写锁的线程会始终期待开释读锁。
有一个线程曾经占用了写锁，则此时其余线程如果申请写锁或者读锁，则申请的线程会始终期待开释写锁。
Thread-0正在进行读操作Thread-0正在进行读操作Thread-0正在进行读操作Thread-0正在进行读操作Thread-1正在进行读操作Thread-1正在进行读操作Thread-1正在进行读操作Thread-1正在进行读操作Thread-1正在进行读操作Thread-1正在进行读操作Thread-1正在进行读操作Thread-1正在进行读操作Thread-1正在进行读操作Thread-1正在进行读操作Thread-0正在进行读操作Thread-0正在进行读操作Thread-0正在进行读操作Thread-0正在进行读操作Thread-0正在进行读操作Thread-0正在进行读操作Thread-1读操作结束Thread-0读操作结束Lock和synchronized的抉择
总结来说，Lock和synchronized有以下几点不同：
1）Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；
2）synchronized在产生异样时，会主动开释线程占有的锁，因而不会导致死锁景象产生；而Lock在产生异样时，如果没有被动通过unLock()去开释锁，则很可能造成死锁景象，因而应用Lock时须要在finally块中开释锁；
3）Lock能够让期待锁的线程响应中断，而synchronized却不行，应用synchronized时，期待的线程会始终期待上来，不可能响应中断；
4）通过Lock能够晓得有没有胜利获取锁，而synchronized却无奈办到。
5）Lock能够进步多个线程进行读操作的效率。
在性能上来说，如果竞争资源不强烈，两者的性能是差不多的，而当竞争资源十分强烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体应用时要依据适当状况抉择。
各种锁
可重入锁
如果锁具备可重入性，则称作为可重入锁。像synchronized和ReentrantLock都是可重入锁，可重入性在我看来实际上表明了锁的分配机制：基于线程的调配，而不是基于办法调用的调配。举个简略的例子，当一个线程执行到某个synchronized办法时，比如说method1，而在method1中会调用另外一个synchronized办法method2，此时线程不用从新去申请锁，而是能够间接执行办法method2。
- synchronized
- ReentrantLock
可中断锁
可中断锁：顾名思义，就是能够相应中断的锁。在Java中，synchronized就不是可中断锁，而Lock是可中断锁。如果某一线程A正在执行锁中的代码，另一线程B正在期待获取该锁，可能因为等待时间过长，线程B不想期待了，想先解决其余事件，咱们能够让它中断本人或者在别的线程中中断它，这种就是可中断锁。
- Lock
偏心锁
偏心锁即尽量以申请锁的程序来获取锁。比方同是有多个线程在期待一个锁，当这个锁被开释时，等待时间最久的线程（最先申请的线程）会取得该所，这种就是偏心锁。非偏心锁即无奈保障锁的获取是依照申请锁的程序进行的。这样就可能导致某个或者一些线程永远获取不到锁。
在Java中，synchronized就是非偏心锁，它无奈保障期待的线程获取锁的程序。而对于ReentrantLock和ReentrantReadWriteLock，它默认状况下是非偏心锁，然而能够设置为偏心锁。
读写锁
读写锁将对一个资源（比方文件）的拜访分成了2个锁，一个读锁和一个写锁。
正因为有了读写锁，才使得多个线程之间的读操作不会发生冲突。
ReadWriteLock就是读写锁，它是一个接口，ReentrantReadWriteLock实现了这个接口。
能够通过readLock()获取读锁，通过writeLock()获取写锁。
- ReentrantReadWriteLock
参考资料：
https://www.cnblogs.com/dolph...