JUC并发编程——读写锁 ReadWriteLock

最新推荐文章于 2024-06-15 19:41:21 发布

原创最新推荐文章于 2024-06-15 19:41:21 发布 · 560 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #juc #readwritelock

JUC并发编程专栏收录该内容

16 篇文章

订阅专栏

本文详细介绍了Java中ReadWriteLock接口的原理与应用，通过对比独占锁，突出了读写锁在多线程环境下对读操作的支持优势，并通过示例演示了如何正确使用ReentrantReadWriteLock来提高程序性能。

文章目录

JUC并发编程——读写锁 ReadWriteLock

JUC并发编程——读写锁 ReadWriteLock

1、ReadWriteLock 简介

ReadWriteLock

在java.util.concurrent.locks包中定义了ReadWriteLock接口,该接口中定义了readLock()返回读锁,定义writeLock()方法返回写锁. 一个用于读操作(readLock读锁)，一个用于写操作(writeLock写锁)。该接口的实现类是ReentrantReadWriteLock(可重入读写锁)。

线程在读取共享数据前必须先持有读锁，该读锁可以同时被多个线程持有，即它是共享的。线程在修改共享数据前必须先持有写锁，写锁是排他的（独占锁），一个线程持有写锁时其他线程无法获得相应的锁。

读锁只是在读线程之间共享,任何一个线程持有读锁时,其他线程都无法获得写锁, 保证线程在读取数据期间没有其他线程对数据进行更新,使得读线程能够读到数据的最新值,保证在读数据期间共享变量不被修改。

读写锁允许：

读读共享：读 - 读操作可以共存
读写互斥：读 - 写操作不能共存
写写互斥：写 - 写操作不能共存

	获得条件	排他性	作用
读锁	写锁未被任意线程持有	对读线程是共享的,对写线程是排他的	允许多个读线程可以同时读取共享数据,保证在读共享数据时,没有其他线程对共享数据进行修改
写锁	该写锁未被其他线程持有,并且相应的读锁也未被其他线程持有	对读线程或者写线程都是排他的	保证写线程以独占的方式修改共享数据

2、ReadWriteLock 使用

模拟缓存数据的写入和读取

不加读写锁的情况

package com.cheng.rw;

import java.util.HashMap;
import java.util.Map;

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

        MyCache myCache = new MyCache();
        //写操作
        for (int i = 0; i < 5; i++) {
            final int temp = i;
            new Thread(()->{
                myCache.set(temp+"",temp+"");
            },String.valueOf(i)).start();
        }
        //读操作
        for (int i = 0; i < 5; i++) {
            final int temp = i;
            new Thread(()->{
                myCache.get(temp+"");
            },String.valueOf(i)).start();
        }

    }
}

class MyCache{

    private volatile Map<String,Object> map = new HashMap<>();

    //写操作
    public void set(String key,Object value){
        System.out.println(Thread.currentThread().getName()+"写入了"+key);
        map.put(key,value);
        System.out.println(Thread.currentThread().getName()+"写入操作完成");

    }
    //读操作
    public void get(String key){
        System.out.println(Thread.currentThread().getName()+"读取了"+key);
        Object o = map.get(key);
        System.out.println(Thread.currentThread().getName()+"读取操作完成");
    }
}

运行查看结果：

在这里插入图片描述

不加读写锁，当前线程在进行写入操作时被其他线程插队。

加上读写锁

package com.cheng.rw;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReentrantReadWriteLock;

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

        MyCacheLock myCache = new MyCacheLock();
        //写操作
        for (int i = 0; i < 5; i++) {
            final int temp = i;
            new Thread(()->{
                myCache.set(temp+"",temp+"");
            },String.valueOf(i)).start();
        }
        //读操作
        for (int i = 0; i < 5; i++) {
            final int temp = i;
            new Thread(()->{
                myCache.get(temp+"");
            },String.valueOf(i)).start();
        }

    }
}

class MyCacheLock{

    private volatile Map<String,Object> map = new HashMap<>();
    private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();//定义读写锁
    //写操作
    public void set(String key,Object value){
        readWriteLock.writeLock().lock();//加上写锁
        try {
            System.out.println(Thread.currentThread().getName()+"写入了"+key);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName()+"写入操作完成");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();//释放写锁
        }

    }
    //读操作
    public void get(String key){
        readWriteLock.readLock().lock();//加上读锁
        try {
            System.out.println(Thread.currentThread().getName()+"读取了"+key);
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName()+"读取操作完成");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();//释放读锁
        }

    }
}