并发编程之重入锁和读写锁

缺乏、安全感 2022-05-14 01:08 265阅读 0赞

Java多线程中，除了sychronized关键字实现多线程之间同步互斥操作，其实还有另外一种高效的机制去完成“同步互斥”操作。即Lock对象，比synchronized关键字更为强大功能，并且有嗅探锁定，多路分支等功能。

# 重入锁 #

分为公平锁和非公平锁，默认非公平锁

public ReentrantLock() {
        sync = new NonfairSync();
    }
    
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

private Lock lock = new ReentrantLock();
     public void method1(){
        try {
             //加锁
            lock.lock();
            System.out.println("当前线程:" + Thread.currentThread().getName() + "进入method1..");
            Thread.sleep(1000);
            System.out.println("当前线程:" + Thread.currentThread().getName() + "退出method1..");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //一定要释放锁，否则其他线程拥有无法获取
            lock.unlock();
        }
    }

以前使用synchronized 关键字进行多线程协同工作时，需要使用Object的wait()阻塞、释放锁，notify()唤醒、不释放锁等进行配合使用。

使用Lock时可以使用新的等待/通知类，Condition一定是针对某一把固定的锁，也就是说，只有在有锁的基础上才会产生Condition。

public class UseCondition {
    
        private Lock lock = new ReentrantLock();
        private Condition condition = lock.newCondition();
    
        public void method1(){
            try {
                lock.lock();
                System.out.println("当前线程：" + Thread.currentThread().getName() + "进入等待状态..");
                Thread.sleep(3000);
                System.out.println("当前线程：" + Thread.currentThread().getName() + "释放锁..");
                // 释放锁，类似于Object.wait()，阻塞于此
                condition.await();
                System.out.println("当前线程：" + Thread.currentThread().getName() +"继续执行...");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    
        public void method2(){
            try {
                lock.lock();
                System.out.println("当前线程：" + Thread.currentThread().getName() + "进入..");
                Thread.sleep(3000);
                System.out.println("当前线程：" + Thread.currentThread().getName() + "发出唤醒..");
                // 不释放锁类，似于Object.notify()
                condition.signal();
                System.out.println("当前线程：" + Thread.currentThread().getName() + "没有释放锁");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    
        public static void main(String[] args) {
    
            final UseCondition uc = new UseCondition();
    
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    uc.method1();
                }
            }, "t1");
    
            Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    uc.method2();
                }
            }, "t2");
    
            t1.start();
            t2.start();
        }
    }

结果：  
![这里写图片描述][70]

# 读写锁 #

核心思想实现读写分离，高并发下特别适合读多写少的场景。

之前的`synchronized`关键字和`ReentrantLock`同一时间只能有一个线程进行访问被锁定的代码，读写锁的机制则不是，本质上分为两把锁，读锁和写锁，在读锁情况下，多个线程可以并发访问资源，只有当是写锁时，只能一个一个的顺序执行。

口诀：读读共享，写写互斥，读写互斥。

public class UseReentrantReadWriteLock {
    
        private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
        private ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();
        private ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();
    
        public void read() {
            try {
                readLock.lock();
                System.out.println("当前线程:" + Thread.currentThread().getName() + "进入...");
                Thread.sleep(3000);
                System.out.println("当前线程:" + Thread.currentThread().getName() + "退出...");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                readLock.unlock();
            }
        }
    
        public void write() {
            try {
                writeLock.lock();
                System.out.println("当前线程:" + Thread.currentThread().getName() + "进入...");
                Thread.sleep(3000);
                System.out.println("当前线程:" + Thread.currentThread().getName() + "退出...");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                writeLock.unlock();
            }
        }
    
        public static void main(String[] args) {
    
            final UseReentrantReadWriteLock urrw = new UseReentrantReadWriteLock();
    
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    urrw.read();
                }
            }, "t1");
            Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    urrw.read();
                }
            }, "t2");
            Thread t3 = new Thread(new Runnable() {
                @Override
                public void run() {
                    urrw.write();
                }
            }, "t3");
            Thread t4 = new Thread(new Runnable() {
                @Override
                public void run() {
                    urrw.write();
                }
            }, "t4");
    
            t1.start(); // R
            t2.start(); // R
    
            // t1.start(); // R
            // t3.start(); // W
    
            t3.start(); // W
            t4.start(); // W
        }
    }

结果：  
![这里写图片描述][70 1]

[70]: /images/20220514/5f1bb3847618403987c9028f9c6ad025.png
[70 1]: /images/20220514/68f64994b3d946e8b060496462828fa1.png