ReadWriteLock读写分离锁

最新推荐文章于 2025-09-25 17:19:52 发布

原创最新推荐文章于 2025-09-25 17:19:52 发布 · 400 阅读

6 ·

CC 4.0 BY-SA版权

文章标签：

#java #jvm #开发语言

本文通过一个Java代码示例，展示了ReentrantReadWriteLock的使用，如何实现读写分离，提高系统性能。当读操作远多于写操作时，读写锁能有效减少线程间的阻塞，使得读操作并行执行，而写操作互斥，显著缩短了程序执行时间。

public class ReadWriteLockDemo {
    private static Lock lock = new ReentrantLock();
    private static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private static Lock readLock = readWriteLock.readLock();
    private static Lock writeLock = readWriteLock.writeLock();
    private int value;

    public Object handleRead(Lock lock) throws InterruptedException{
        try{
            lock.lock();
            Thread.sleep(1000);
            return value;
        }finally {
            lock.unlock();
        }
    }

    public void handleWrite(Lock lock,int index) throws InterruptedException{
        try{
            lock.lock();
            Thread.sleep(1000);
            value = index;
        }finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        final ReadWriteLockDemo demo = new ReadWriteLockDemo();
        Runnable readRunnale = new Runnable(){
            @Override
            public void run() {
                try{
                    demo.handleRead(readLock);
                    //demo.handleRead(lock);
                } catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        };

        Runnable writeRunnale = new Runnable(){
            @Override
            public void run() {
                try{
                    demo.handleWrite(writeLock,new Random().nextInt());
                    //demo.handleWrite(lock,new Random().nextInt());
                } catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        };

        for(int i = 0;i <18; i++){
            new Thread(readRunnale).start();
        }
        for(int i =18;i<20;i++){
            new Thread(writeRunnale).start();
        }


    }

}

ReadWriteLock读写分离锁。
读写分离锁可以有效地帮助减少竞争。
读-读不互斥：读读之间不阻塞
读-写互斥：读阻塞写，写也会阻塞读。
写-写互斥：写写阻塞。
如果在系统中，读操作的次数远远大于写操作的次数，
则读写锁就可以发挥最大的功效，提升系统的性能。

Thread.sleep(1000);让线程耗时1秒，让他们分别对应读耗时和写耗时。
开启18个读线程，开启2个写线程。由于这里使用了读写分离。
因此，读线程完全并行，而写会堵塞读，因为，实际上这段代码运行大约2秒多就结束。
写线程之间实际是串行的。
而如果
//demo.handleRead(lock);替代上一行。
//demo.handleWrite(lock,new Random().nextInt()); 替代上一行
即使用普通的重入锁代替读写锁，所有的读和写线程之间都必须相互等待。
因此整个程序的执行时间将长达20余秒。