并发编程12-显示锁

内部所拥有比较好的性能，但是在灵活性方面有缺陷，并且如果申请锁失败就会陷入阻塞等待的过程中。
对于一些场景，我们可以使用显示锁Lock

基本应用

Lock 的lock方法相当于进入同步块， unlock方法相当于退出同步块。支持跟内部锁同样的重入机制：

    public void displayLock(){Lock lock = new ReentrantLock();lock.lock();try{}finally{lock.unlock();}}public void innerLock(){Object lock = new Object();synchronized (lock){}}

可以看出内部锁的代码还有清爽一点，显示锁需要在finally中释放

tryLock避免死锁

先看下死锁的情况：

public class TestLock {public static void main(String[] args) {final Accout accout1 = new Accout(20);final Accout accout2 = new Accout(20);final TestLock testLock = new TestLock();new Thread(){@Overridepublic void run() {testLock.transferMoney(accout2, accout1, 10);}}.start();testLock.transferMoney(accout1, accout2, 10);}public void transferMoney(Accout accout1, Accout accout2, int money){synchronized (accout1){try {TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {e.printStackTrace();}synchronized (accout2){accout1.add(money);accout2.decrease(money);System.out.println(accout1.getAccout());System.out.println(accout2.getAccout());}}}
}class Accout{public Accout(int accout){this.accout = accout;}public Lock lock = new ReentrantLock();private int accout;public void add(int money){accout += money;}public void decrease(int money){accout -= money;}public int getAccout() {return accout;}
}

改为不会死锁的情况：

public void transferMoney(Accout accout1, Accout accout2, int money){if(accout1.lock.tryLock()){try {TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {e.printStackTrace();}if(accout2.lock.tryLock()){accout1.add(money);accout2.decrease(money);System.out.println(accout1.getAccout());System.out.println(accout2.getAccout());accout2.lock.unlock();      // sould be in finally block}accout1.lock.unlock();      // sould be in finally block}}

如上其实主要是利用了tryLock当获取不到锁就返回false的特性。另外tryLock还能设置超时时间，指定时间得不到锁才返回false.

tryLock可中断锁

当代码遇到锁标记有很多种选择，获得锁，如果锁不再了等待锁，重入进该锁，响应中断。
通常的锁在需要等待的时候并不会响应中断。
如下：

public class TestLock {public static void main(String[] args) {new TestLock().testUnInterrupt();}public void testUnInterrupt(){Lock lock = new ReentrantLock();ThreadTest t1 = new ThreadTest(lock, "t1");t1.start();ThreadTest t2 = new ThreadTest(lock, "t2");t2.start();t2.interrupt();}
}class ThreadTest extends Thread{private Lock lock;public ThreadTest(Lock lock, String name){super(name);this.lock = lock;}@Overridepublic void run(){lock.lock();System.out.println(getName() + "运行开始");
//        try {//            lock.lockInterruptibly();
//        } catch (InterruptedException e) {//            System.out.println(getName() + "锁等待被中断");
//            e.printStackTrace();
//        }try {TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {System.out.println(getName() + "休眠被中断");
//            e.printStackTrace();} finally {lock.unlock();}System.out.println(getName() + "运行完成");}
}

使用lock()的返回结果：

t1运行开始
t2运行开始
t1运行完成
t2休眠被中断
t2运行完成

使用lockInterruptibly()的返回结果：

t1运行开始
t2运行开始
t2锁等待被中断

可见lockInterruptibly与普通锁的区别在于可以在锁等待的时候响应中断

lock和synchronized性能

在JDK6之前性能上Lock要好很多，但是JDK6之后改进了内部锁的算法，现在差不多

公平锁

ReentrantLock锁的构造器中可以选择是否公平，公平的意思就是开始执行的顺序将会按照锁等待的顺序。这样会造成性能下降，只有在对顺序敏感的时候才需要。

synchronized还是ReentrantLock

性能上JDK1.6，ReentrantLock略好。
ReentrantLock可以支持复杂的语义。
ReentrantLock需要显示关闭
synchronized语法上更简单易用
综上，其实应该更多的使用synchoronized，只有在有必要的时候才使用ReentrantLock

读写锁

普通的锁限制了并发性，对于数据无害的读-读操作也会出现锁竞争。这个时候可以使用读写锁
读写锁的一些特性：
- 基本功能就是有写入的时候要等写完完成才能再执行写入，如果没有写入的时候读是可以并发的
- 可降级不可以升级，就是读解锁前如果获取写锁会死锁，但是写锁中是可以获取读锁的
- 各锁单独可重入
如下：

public class TestLock {public static void main(String[] args) {final Cache cache = new Cache();new Thread(){@Overridepublic void run() {cache.add("1");cache.add("2");cache.add("3");}}.start();new Thread(){@Overridepublic void run() {cache.get();}}.start();new Thread(){@Overridepublic void run() {cache.get();}}.start();}
}class Cache{ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();List<String> datas = new ArrayList<String>();public void add(String data){rwl.writeLock().lock();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}datas.add(data);System.out.println("添加" + data);rwl.writeLock().unlock();}public String get(){rwl.readLock().lock();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}String data = datas.get(0);datas.remove(0);rwl.readLock().unlock();System.out.println("获得" + data);return data;}
}

可以验证写锁互斥，读写并发。