并发编程12-显示锁

男娘i 2022-08-07 01:46 206阅读 0赞

内部所拥有比较好的性能，但是在灵活性方面有缺陷，并且如果申请锁失败就会陷入阻塞等待的过程中。  
对于一些场景，我们可以使用显示锁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(){
                @Override
                public 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;
        }
        @Override
        public 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(){
                @Override
                public void run() {
                    cache.add("1");
                    cache.add("2");
                    cache.add("3");
                }
            }.start();
    
            new Thread(){
                @Override
                public void run() {
                    cache.get();
                }
            }.start();
            new Thread(){
                @Override
                public 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;
        }
    }

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