多线程读写锁问题：创建读写锁，让多线程能同时读取数据，写写互斥，写读互斥

Java并发编程：使用读写锁实现多线程读写操作

最新推荐文章于 2025-03-17 10:23:18 发布

原创最新推荐文章于 2025-03-17 10:23:18 发布 · 719 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#多线程 #并发编程 #java

多线程专栏收录该内容

2 篇文章

订阅专栏

该博客演示了如何在Java中使用ReentrantReadWriteLock实现读写锁，确保多线程环境下读取操作的并行性和写入操作的互斥。通过创建线程池并分配任务，展示了读写锁在高并发场景下的应用，以提高程序的效率。

部署运行你感兴趣的模型镜像

package com.qf.demo2;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 读写锁问题：创建读写锁，让多线程能同时读取数据，写写互斥，写读互斥
 * @Author XZG
 * @Date: 2020/10/31 14:48
 * @Version 1.0
 */

public class WriteAndReadLockTest {
    public static void main(String[] args) {

        //创建新的线程池对象
        ExecutorService es1 = Executors.newFixedThreadPool(20);
        //创建新的读写锁
        WriteAndReadLock warl = new WriteAndReadLock();
        //获取开始的时间
        long startTime = System.currentTimeMillis();

        /*从线程池中拿出两个线程执行写入任务*/
        for (int i = 1; i <= 2; i++) {
            es1.submit(new Runnable() {
                @Override
                public void run() {
                    //调用读写锁的写入方法
                    warl.setNum(12);
                }
            });
        }

        /*从线程池中拿出两个线程执行读取任务*/
        for (int i = 1; i <= 18; i++) {
            es1.submit(new Runnable() {
                @Override
                public void run() {
                    //调用读写锁的读取方法
                    warl.getNum();
                }
            });
        }

        es1.shutdown();
        /*确保此时的线程池已经完全关闭*/
        while (true){
            if (es1.isTerminated()){
                long endTime = System.currentTimeMillis();
                long allTime = endTime - startTime;
                System.out.println(allTime);
                System.out.println("执行时间为" + allTime + "ms");
                break;
            }
        }
    }
}

创建读写锁类，声明读取和写入的方法，同时给读取写入上锁，确保写写互斥

package com.qf.demo2;

import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 *
 * @Author XZG
 * @Date: 2020/10/31 14:35
 * @Version 1.0
 */

public class WriteAndReadLock {

    //创建读写锁
    ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    //通过读写锁，获得读取锁
    ReentrantReadWriteLock.ReadLock rl = rwl.readLock();
    //通过读写锁，获得写入锁
    ReentrantReadWriteLock.WriteLock wl = rwl.writeLock();

    //声明一个变量
    public Integer num;

    public Integer getNum(){

        //给读取上锁
        rl.lock();
        try {
            Thread.sleep(1000);
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("读取成功" + num);
        //给读取解锁
        rl.unlock();
        //返回读取到的值
        return num;
    }

    public void setNum(Integer num){

        //给写入上锁
        wl.lock();

        try {
            Thread.sleep(1000);
            //设置num
            this.num = num;
            System.out.println("设置成功");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //给写入解锁
        wl.unlock();
    }

}