乐趣区

关于java:阿里一面ReadWriteLock-读写之间互斥吗我竟然答不上来

jiezi

开发中遇到并发的问题个别会用到锁，Synchronized 存在显著的一个性能问题就是读与读之间互斥；ReadWriteLock 是 JDK5 中提供的读写拆散锁。读写拆散锁能够无效地帮忙缩小锁竞争，以晋升零碎的性能。

ReadWriteLock 治理一组锁，一个是只读的锁，一个是写锁。
Java 并发库中 ReetrantReadWriteLock 实现了 ReadWriteLock 接口并增加了可重入的个性。

而读写锁 ReentrantReadWriteLock：读读共享，读写互斥，写写互斥；读写锁保护了一对锁，一个读锁，一个写锁，通过拆散读锁和写锁，使得并发性相比个别的排他锁有了很大晋升。在读多写少的状况下，读写锁可能提供比排他锁更好的并发性和吞吐量。

从源码中能够看出，读写锁中同样依赖队列同步器 Sync(AQS) 实现同步性能，而读写状态就是其同步器的同步状态。上面从例子中来阐明：读读共享，读写互斥，写写互斥。

代码如下：

public class ReentrantWriteReadLockTest {ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    ReadLock readLock = lock.readLock();
    WriteLock writeLock = lock.writeLock();

    public void read(){
        try {readLock.lock();
            System.out.println("线程"+Thread.currentThread().getName()+"进入。。。");
            Thread.sleep(3000);
            System.out.println("线程"+Thread.currentThread().getName()+"退出。。。");
        } catch (InterruptedException 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 (InterruptedException e) {e.printStackTrace();
        }finally{writeLock.unlock();
        }
    }

    public static void main(String[] args) {final ReentrantWriteReadLockTest wr = new ReentrantWriteReadLockTest();
        Thread t1 = new Thread(new Runnable() {public void run() {wr.read();
            }
        }, "t1");
        Thread t2 = new Thread(new Runnable() {public void run() {wr.read();
            }
        }, "t2");
        Thread t3 = new Thread(new Runnable() {public void run() {wr.write();
            }
        }, "t3");
        Thread t4 = new Thread(new Runnable() {public void run() {wr.write();
            }
        }, "t4");

        t1.start();
        t2.start();
        //t3.start();
        //t4.start();}
}

当咱们启动线程 t1 和 t2 时，后果如下：

线程 t1 和 t2 能够同时进入，阐明了读读共享！

当咱们启动线程 t2 和 t3 时，后果如下：

一个线程必须期待另一个线程退出，能力进入，阐明了读写互斥！

当咱们启动线程 t3 和 t4 时，后果如下：

一个线程必须期待另一个线程退出，能力进入，阐明了写写互斥！

起源：https://www.cnblogs.com/liuqi…

近期热文举荐：

1.1,000+ 道 Java 面试题及答案整顿 (2022 最新版)

2. 劲爆！Java 协程要来了。。。

3.Spring Boot 2.x 教程，太全了！

4. 别再写满屏的爆爆爆炸类了，试试装璜器模式，这才是优雅的形式！！

5.《Java 开发手册（嵩山版）》最新公布，速速下载！

感觉不错，别忘了顺手点赞 + 转发哦！

退出移动版