ReadWriteLock的使用

学习地址:狂神Bilibili个人主页

1.什么是ReadWriteLock?

ReadWriteLock(读写锁)维护一对关联的锁,一个用于只读操作一个用于写。在没有写线程的情况下一个读锁可能会同时被多个读线程 持有;写锁是独占的
在这里插入图片描述

  • 独占锁(写锁) 一次只能被一个线程占有
  • 共享锁(读锁) 多个线程可以同时占有
2.没加读写锁代码示例

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();

        // 写入
        for (int i = 1; i <= 5 ; i++) {
            final int temp = i;
            new Thread(()->{
                myCache.put(temp+"",temp+"");
            },String.valueOf(i)).start();
        }

        // 读取
        for (int i = 1; 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 put(String key,Object value){
        System.out.println(Thread.currentThread().getName()+"写入"+key);
        map.put(key,value);
        System.out.println(Thread.currentThread().getName()+"写入OK");
    }

    // 取,读
    public void get(String key){
        System.out.println(Thread.currentThread().getName()+"读取"+key);
        Object o = map.get(key);
        System.out.println(Thread.currentThread().getName()+"读取OK");
    }

}

在这里插入图片描述
结果分析:在一个进程写入的时候,其他进入也可以进入,这是不符合逻辑的

4.加了读写锁的代码示例

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 独占锁(写锁) 一次只能被一个线程占有
 * 共享锁(读锁) 多个线程可以同时占有
 * ReadWriteLock
 * 读-读  可以共存!
 * 读-写  不能共存!
 * 写-写  不能共存!
 */
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();

        // 写入
        for (int i = 1; i <= 5 ; i++) {
            final int temp = i;
            new Thread(()->{
                myCache.put(temp+"",temp+"");
            },String.valueOf(i)).start();
        }

        // 读取
        for (int i = 1; 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 ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private Lock lock = new ReentrantLock();

    // 存,写入的时候,只希望同时只有一个线程写
    public void put(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()+"写入OK");
        } 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()+"读取OK");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }
    }

}

在这里插入图片描述

结果分析:一个线程写入,直到该线程写完,其他线程才能写;可以多个线程读取,非常符合逻辑

5.读写锁的三个状态
  • 写-写(不能共存):当读写锁是加锁状态时,在这个锁被解锁之前,所有试图对这个锁加锁的线程都会被阻塞
  • 读-读(能共存): 当读写锁在加锁状态时,所有试图以读模式对它进行加锁的线程都可以得到访问权,但是以写模式对它进行加锁的线程将会被阻塞
  • 读-写(不能共存):当读写锁在模式的锁状态时,如果有另外的线程试图以写模式加锁,读写锁通常会阻塞随后的读模式锁的请求,这样可以避免读模式锁长期占用,而等待的写模式锁请求则长期阻塞。
  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ReadWriteLockJava中提供的一种读写锁机制,它允许多个线程同时读取共享资源,但只允许一个线程写入共享资源。ReadWriteLock中包含一个读锁和一个写锁,读锁可以被多个线程同时持有,但写锁只能被一个线程持有。 下面是ReadWriteLock使用示例: ```java import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; public class ReadWriteLockDemo { private static final ReadWriteLock lock = new ReentrantReadWriteLock(); private static int value = 0; public static void main(String[] args) { // 创建10个读线程和1个写线程 for (int i = 0; i < 10; i++) { new Thread(new ReadTask()).start(); } new Thread(new WriteTask()).start(); } // 读线程 static class ReadTask implements Runnable { public void run() { lock.readLock().lock(); // 获取读锁 try { System.out.println(Thread.currentThread().getName() + " read " + value); } finally { lock.readLock().unlock(); // 释放读锁 } } } // 写线程 static class WriteTask implements Runnable { public void run() { lock.writeLock().lock(); // 获取写锁 try { value++; // 修改共享变量 System.out.println(Thread.currentThread().getName() + " write " + value); } finally { lock.writeLock().unlock(); // 释放写锁 } } } } ``` 在上面的示例中,我们定义了一个ReadWriteLock对象,并创建了10个读线程和1个写线程。读线程通过调用readLock()方法获取读锁,写线程通过调用writeLock()方法获取写锁,并在访问共享变量后释放锁。由于读锁允许多个线程同时持有,所以读线程可以同时执行,而写线程必须等到所有读线程执行完毕后才能执行。 需要注意的是,由于ReadWriteLock是基于Lock接口实现的,因此在使用ReadWriteLock时需要注意锁的获取和释放顺序,避免出现死锁或者锁竞争等问题。同时,在使用ReadWriteLock时也需要注意共享变量的可见性和线程安全性,避免出现数据不一致等问题。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值