Java中的读写锁

最新推荐文章于 2024-05-01 07:08:38 发布
最新推荐文章于 2024-05-01 07:08:38 发布
阅读量527 收藏 12
点赞数 8
分类专栏： JUC 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CSDN_GIA/article/details/135666039
版权

一、ReentrantReadWriteLock

两个线程同时读取，不会互斥:

@Slf4j
public class ReadWriteLockTest {
    public static void main(String[] args) throws InterruptedException {
        DataContainer dataContainer = new DataContainer();
        new Thread(dataContainer::read, "t1").start();
        //Thread.sleep(1000);
        new Thread(dataContainer::read, "t2").start();
    }
}

@Slf4j
class DataContainer {
    private Object data;
    private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
    private ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();

    public Object read() {
        readLock.lock();
        log.debug("获取读锁");
        try {
            log.debug("读取");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return data;
        } finally {
            readLock.unlock();
            log.debug("释放读锁");
        }
    }

    public void write() {
        writeLock.lock();
        log.debug("获取写锁");
        try {
            log.debug("写入");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } finally {
            writeLock.unlock();
            log.debug("释放写锁");
        }
    }
}


13:52:32.177 [t2] DEBUG juc.readwrite.DataContainer - 获取读锁
13:52:32.177 [t1] DEBUG juc.readwrite.DataContainer - 获取读锁
13:52:32.180 [t1] DEBUG juc.readwrite.DataContainer - 读取
13:52:32.180 [t2] DEBUG juc.readwrite.DataContainer - 读取
13:52:33.181 [t1] DEBUG juc.readwrite.DataContainer - 释放读锁
13:52:33.181 [t2] DEBUG juc.readwrite.DataContainer - 释放读锁

一个线程读取，一个线程写入，会互斥：

@Slf4j
public class ReadWriteLockTest {
    public static void main(String[] args) throws InterruptedException {
        DataContainer dataContainer = new DataContainer();
        new Thread(dataContainer::read, "t1").start();
        Thread.sleep(1000);
        new Thread(dataContainer::write, "t2").start();
    }
}

@Slf4j
class DataContainer {
    private Object data;
    private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
    private ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();

    public Object read() {
        readLock.lock();
        log.debug("获取读锁");
        try {
            log.debug("读取");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return data;
        } finally {
            readLock.unlock();
            log.debug("释放读锁");
        }
    }

    public void write() {
        writeLock.lock();
        log.debug("获取写锁");
        try {
            log.debug("写入");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } finally {
            writeLock.unlock();
            log.debug("释放写锁");
        }
    }
}

13:53:26.922 [t1] DEBUG juc.readwrite.DataContainer - 获取读锁
13:53:26.924 [t1] DEBUG juc.readwrite.DataContainer - 读取
13:53:27.928 [t1] DEBUG juc.readwrite.DataContainer - 释放读锁
13:53:27.929 [t2] DEBUG juc.readwrite.DataContainer - 获取写锁
13:53:27.929 [t2] DEBUG juc.readwrite.DataContainer - 写入
13:53:28.931 [t2] DEBUG juc.readwrite.DataContainer - 释放写锁

两个线程读同时写入，会互斥：

@Slf4j
public class ReadWriteLockTest {
    public static void main(String[] args) throws InterruptedException {
        DataContainer dataContainer = new DataContainer();
        new Thread(dataContainer::write, "t1").start();
        Thread.sleep(1000);
        new Thread(dataContainer::write, "t2").start();
    }
}

@Slf4j
class DataContainer {
    private Object data;
    private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
    private ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();

    public Object read() {
        readLock.lock();
        log.debug("获取读锁");
        try {
            log.debug("读取");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return data;
        } finally {
            readLock.unlock();
            log.debug("释放读锁");
        }
    }

    public void write() {
        writeLock.lock();
        log.debug("获取写锁");
        try {
            log.debug("写入");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } finally {
            writeLock.unlock();
            log.debug("释放写锁");
        }
    }
}

13:55:19.834 [t1] DEBUG juc.readwrite.DataContainer - 获取写锁
13:55:19.837 [t1] DEBUG juc.readwrite.DataContainer - 写入
13:55:20.840 [t1] DEBUG juc.readwrite.DataContainer - 释放写锁
13:55:20.849 [t2] DEBUG juc.readwrite.DataContainer - 获取写锁
13:55:20.849 [t2] DEBUG juc.readwrite.DataContainer - 写入
13:55:21.850 [t2] DEBUG juc.readwrite.DataContainer - 释放写锁
1.读锁不支持条件变量
2.锁升级不支持重入

持有读锁的情况下去获取写锁，会导致写锁永久等待:

r.lock();
try{
  //...
  w.lock();
  try{
    //...
  } finally{
    w.unlock();
 }
} finally{
  r.unlock();
}
3.锁降级支持重入

持有写锁的情况下去获取读锁，支持。

class CachedData {
    Object data;
    // 是否有效，如果失效，需要重新计算 data
    volatile boolean cacheValid;
    final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

    void processCachedData() {
        rwl.readLock().lock();
        if (!cacheValid) {
            //获取写锁前必须释放读锁
            rwl.readLock().unlock();
            rwl.writeLock().lock();
            try {
                // 判断是否有其它线程已经获取了写锁、更新了缓存，避免重复更新
                if (!cacheValid) {
                    data = ...
                    cacheValid = true;
                }
                // 降级为读锁，释放写锁，这样能够让其它线程读取缓存
                rwl.readLock().lock();
            } finally {
                rwl.writeLock().unlock();
            }
        }
        // 自己用完数据，释放读锁
        try {
            use(data);
        } finally {
            rwl.readLock().unlock();
        }
    }
}

二、缓存更新策略

1.先清缓存，再更新数据库

先清缓存.png

2.先更新数据库，再清缓存

image.png

使用读写锁解决：

public class TestGenericDao {
    public static void main(String[] args) {
        GenericDao dao = new GenericDaoCached();
        System.out.println("============> 查询");
        String sql = "select * from emp where empno = ?";
        int empno = 7369;
        Emp emp = dao.queryOne(Emp.class, sql, empno);
        System.out.println(emp);
        emp = dao.queryOne(Emp.class, sql, empno);
        System.out.println(emp);
        emp = dao.queryOne(Emp.class, sql, empno);
        System.out.println(emp);

        System.out.println("============> 更新");
        dao.update("update emp set sal = ? where empno = ?", 800, empno);
        emp = dao.queryOne(Emp.class, sql, empno);
        System.out.println(emp);
    }
}

class GenericDaoCached extends GenericDao {
    private GenericDao dao = new GenericDao();
    private Map<SqlPair, Object> map = new HashMap<>();
    private ReentrantReadWriteLock rw = new ReentrantReadWriteLock();

    @Override
    public <T> List<T> queryList(Class<T> beanClass, String sql, Object... args) {
        return dao.queryList(beanClass, sql, args);
    }

    @Override
    public <T> T queryOne(Class<T> beanClass, String sql, Object... args) {
        // 先从缓存中找，找到直接返回
        SqlPair key = new SqlPair(sql, args);;
        rw.readLock().lock();
        try {
            T value = (T) map.get(key);
            if(value != null) {
                return value;
            }
        } finally {
            rw.readLock().unlock();
        }
        rw.writeLock().lock();
        try {
            // 多个线程
            T value = (T) map.get(key);
            if(value == null) {
                // 缓存中没有，查询数据库
                value = dao.queryOne(beanClass, sql, args);
                map.put(key, value);
            }
            return value;
        } finally {
            rw.writeLock().unlock();
        }
    }

    @Override
    public int update(String sql, Object... args) {
        rw.writeLock().lock();
        try {
            // 先更新库
            int update = dao.update(sql, args);
            // 清空缓存
            map.clear();
            return update;
        } finally {
            rw.writeLock().unlock();
        }
    }

    class SqlPair {
        private String sql;
        private Object[] args;

        public SqlPair(String sql, Object[] args) {
            this.sql = sql;
            this.args = args;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            SqlPair sqlPair = (SqlPair) o;
            return Objects.equals(sql, sqlPair.sql) &&
                    Arrays.equals(args, sqlPair.args);
        }

        @Override
        public int hashCode() {
            int result = Objects.hash(sql);
            result = 31 * result + Arrays.hashCode(args);
            return result;
        }
    }
}

三、StampedLock

JDK 8 加入，是为了进一步优化读性能，它的特点是在使用读锁、写锁时都必须配合【戳】使用：
加解读锁：

long stamp = lock.readLock();
lock.unlockRead(stamp);

加解写锁:

long stamp = lock.writeLock();
lock.unlockWrite(stamp);

乐观读
乐观读，StampedLock 支持 tryOptimisticRead() 方法（乐观读），读取完毕后需要做一次 戳校验， 如果校验通过，表示这期间确实没有写操作，数据可以安全使用，如果校验没通过，需要重新获取读锁，保证数据安全。

long stamp = lock.tryOptimisticRead();
// 验戳
if(!lock.validate(stamp)){
// 锁升级
}

读读，使用乐观读：

package juc.readwrite;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.locks.StampedLock;


@Slf4j
public class StampedLockTest {
    public static void main(String[] args) throws InterruptedException {
        DataContainerStamped dataContainer = new DataContainerStamped(1);
        new Thread(() -> dataContainer.read(1000), "t1").start();
        Thread.sleep(500);
        new Thread(() -> dataContainer.read(0), "t2").start();
    }
}

@Slf4j
class DataContainerStamped {
    private int data;
    private final StampedLock lock = new StampedLock();

    public DataContainerStamped(int data) {
        this.data = data;
    }

    public int read(int readTime) {
        long stamp = lock.tryOptimisticRead();
        log.debug("optimistic read locking...{}", stamp);
        try {
            Thread.sleep(readTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (lock.validate(stamp)) {
            log.debug("read finish...{}, data:{}", stamp, data);
            return data;
        }
        // 锁升级 - 读锁
        log.debug("updating to read lock... {}", stamp);
        try {
            stamp = lock.readLock();
            log.debug("read lock {}", stamp);
            try {
                Thread.sleep(readTime);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.debug("read finish...{}, data:{}", stamp, data);
            return data;
        } finally {
            log.debug("read unlock {}", stamp);
            lock.unlockRead(stamp);
        }
    }

    public void write(int newData) {
        long stamp = lock.writeLock();
        log.debug("write lock {}", stamp);
        try {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.data = newData;
        } finally {
            log.debug("write unlock {}", stamp);
            lock.unlockWrite(stamp);
        }
    }
}

16:32:53.802 [t1] DEBUG juc.readwrite.DataContainerStamped - optimistic read locking...256
16:32:54.299 [t2] DEBUG juc.readwrite.DataContainerStamped - optimistic read locking...256
16:32:54.300 [t2] DEBUG juc.readwrite.DataContainerStamped - read finish...256, data:1
16:32:54.814 [t1] DEBUG juc.readwrite.DataContainerStamped - read finish...256, data:1

读写，乐观读升级为读锁：

@Slf4j
public class StampedLockTest {
    public static void main(String[] args) throws InterruptedException {
        DataContainerStamped dataContainer = new DataContainerStamped(1);
        new Thread(() -> dataContainer.read(1000), "t1").start();
        Thread.sleep(500);
        new Thread(() -> dataContainer.write(1000), "t2").start();
    }
}

16:35:01.050 [t1] DEBUG juc.readwrite.DataContainerStamped - optimistic read locking...256
16:35:01.548 [t2] DEBUG juc.readwrite.DataContainerStamped - write lock 384
16:35:02.057 [t1] DEBUG juc.readwrite.DataContainerStamped - updating to read lock... 256
16:35:03.549 [t2] DEBUG juc.readwrite.DataContainerStamped - write unlock 384
16:35:03.549 [t1] DEBUG juc.readwrite.DataContainerStamped - read lock 513
16:35:04.551 [t1] DEBUG juc.readwrite.DataContainerStamped - read finish...513, data:1000
16:35:04.551 [t1] DEBUG juc.readwrite.DataContainerStamped - read unlock 513

不支持条件变量，不支持重入

我可能是个假开发
关注
  • 8
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java编程读写锁详解
08-27
Java编程读写锁是Java并发编程中的一种重要机制，用于解决多线程访问同一个资源时的安全问题。在Java中，读写锁是通过ReadWriteLock接口实现的，该接口提供了readLock和writeLock两种锁的操作机制，一个资源可以被多...
Java并发多线程编程——读写锁的理解与代码示例
小志的博客
04-26 358
目录一、读写锁的理解二、读写锁的代码示例三、多个线程进行读操作的测试案例四、多个线程进行写操作的测试案例五、多个线程进行读写操作的测试案例 一、读写锁的理解 读写锁实际维护了一对锁，一个读锁，一个写锁，通过分离读锁和写锁，使得其并发性比独占式锁(排他锁)有了很大的提升。 读锁（共享锁）：同一时刻可以允许多个线程访问共享资源。 写锁（排他锁）：在写线程访问的时候，所有的读线程和其他写线程都会被阻塞。即如果一个线程想要去写共享资源，就不应该再有其他线程可以对该共享资源进行读或者是写操作了。 二、读写锁的代码
java线程之读写锁
一起coding，一起嗨。
05-10 7097
一、什么是读写锁 读写锁是JDK1.5提供的一个工具锁，适用于读多写少的场景，将读写分离，从而提高并发性。 二、读写锁的特点 读锁是共享锁，写锁是排他锁，读锁和写锁不能同时存在； 读锁不能升级为写锁； 写锁可以降级为读锁； 三、代码演示 import java.util.HashMap; import java.util.Map; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Lo
读写锁精讲：Java中使用ReadWriteLock提升性能的终极指南
最新发布
逆流的小鱼
05-01 1442
在并发编程中，ReadWriteLock是一个锁，它允许多个线程同时读共享数据，而写操作则是互斥的。这意味着如果没有线程正在对数据进行写入，那么多个线程可以同时进行读取操作，从而提高程序的性能和吞吐量。
Java读写锁 ReadWriteLock
m0_71777195的博客
12-10 1537
维护一对关联的locks，一个用于只读操作，一个用于写操作。read lock可以由多个阅读器同时进行，只要没有作者write lock是独家的。基本意思可分为如下几种场景写锁不存在、多次加读锁成功写锁存在、加读锁失败、加写锁失败读锁不存在、单次加写锁成功、多次加写锁只有第一个写锁能成功读锁存在、加读锁成功、加写锁失败复制代码。
Java读写锁浅析
luoxn28的专栏
05-09 415
Java读写锁，也就是ReentrantReadWriteLock，其包含了读锁和写锁，其中读锁是可以多线程共享的，即共享锁，而写锁是排他锁，在更改时候不允许其他线程操作。读写锁底层是同一...
Java进阶篇--读写锁
m0_74293254的博客
10-17 1832
而当某个线程需要更新共享数据时，需要获取写锁，此时所有的读线程和其他写线程都会被阻塞，保证数据的一致性。按照锁降级的规则，持有写锁的线程可以首先获取读锁，然后再释放写锁，以将写锁降级为读锁，不支持锁升级。读写锁的使用可以提高程序的并发读取能力，减少读操作之间的互斥等待，从而提高程序的性能和响应速度。需要注意的是，锁降级是允许的，因为读锁是共享的，多个线程可以同时持有读锁。需要注意的是，读锁与写锁是互斥的，即当存在一个线程持有写锁时，其他线程无法同时获取读锁或写锁。最后，在释放写锁之前，执行读操作。
Java 读写锁 ReadWriteLock 原理与应用场景详解
萌兔兔MMQ！！
09-30 3824
主要是为了保证数据的可见性，如果当前线程不获取读锁而直接释放写锁，假设此刻另一个线程获取的写锁，并修改了数据，那么当前线程就步伐感知到线程T的数据更新，如果当前线程遵循锁降级的步骤，那么线程T将会被阻塞，直到当前线程使数据并释放读锁之后，线程T才能获取写锁进行数据更新。或者锁状态不为零，而写锁的状态也不为0，但是获取写锁的线程不是当前线程，则当前线程不能获取写锁。公平性：读写锁支持非公平和公平的锁获取方式，非公平锁的吞吐量优于公平锁的吞吐量，默认构造的是非公平锁。
Java 读写锁实现原理浅析
08-27
Java 读写锁实现原理浅析是 Java 并发编程中一个非常重要的主题。在多线程编程中，读写锁是解决读写并发问题的常用机制。本文主要介绍了 Java 读写锁实现原理浅析，包括读写锁的定义、读写锁的实现原理、...
举例说明Java多线程编程中读写锁的使用
09-02
Java多线程编程中，读写锁是一种优化并发访问共享资源的有效工具，它允许多个线程同时读取，但只允许一个线程写入。Java的`java.util.concurrent.locks.ReentrantReadWriteLock`类提供了可重入的读写锁功能。下面...
java 读写锁代码
08-22
下面我们将详细探讨Java读写锁的概念、实现原理以及如何在实际代码中应用。 1. **读写锁概念**： - 读写锁分为读锁（共享锁）和写锁（独占锁）。读锁允许多个线程同时读取数据，而写锁只允许一个线程进行写操作。 ...
Java多线程编程之读写锁ReadWriteLock用法实例
09-03
Java的多线程编程中，读写锁（ReadWriteLock）是一种高效的并发控制机制，它将锁的权限进行了区分，允许多个线程同时读取资源，但仅允许一个线程进行写入操作。这种设计模式提高了数据共享的效率，因为读操作通常...
关于Java中的读写锁ReentrantReadWriteLock
qq_44911340的博客
03-29 914
Java中的读写锁是一种特殊的同步机制，允许多个线程同时读取共享资源，但只允许一个线程写入共享资源。读写锁的实现基于AQS框架，可以用于解决高并发场景下的数据争用问题，提高程序的并发性和吞吐量。读写锁是一种特殊的同步机制，它允许多个线程同时读取共享资源，但只允许一个线程写入共享资源。（1）实现复杂：读写锁的实现比较复杂，需要考虑读锁和写锁之间的互斥关系，以及锁的粒度和并发性等问题。（2）减少锁竞争：读写锁允许多个线程同时读取，但只允许一个线程写入，可以减少锁竞争带来的性能损耗。5.1 数据库读写分离。
Java 读写锁范例 官方版
qq_42482205的博客
07-26 395
Java Api ReentranReadWriteLock 自带实例 代码： class CachedData { Object data; volatile boolean cacheValid; ReentrantReadWriteLock rwl = new ReentrantReadWriteLock(); void processCachedData() { rwl.readLock().lock();//@1 if (!cacheValid) {
Java中如何实现一个“读写锁“呢？
qq_25073223的博客
08-31 1020
java实现可重入锁的示例分享
Java-并发-锁-ReadWriteLock
迷路剑客个人博客
12-21 780
Java-并发-锁-ReadWriteLock 摘要 现在大家开发程序，大多是在多线程场景，就会用到各种锁。 但其实往往读和读之间是不冲突的，是无状态无修改的，不应该互相互斥。我们往往只需在读写或者写与写之间互斥即可。在JDK中就直接提供了一个ReadWriteLock，本文会介绍其基本概念及分析源码。 0x01 基本概念 ReadWriteLock的互斥关系如下表： 读 写 读...
java锁-ReadWriteLock
qq_29899535的博客
11-26 658
java锁-ReadWriteLock 详细讨论java中ReadWriteLock实现类的底层加锁原理和应用。 文章目录java锁-ReadWriteLock前言总结 前言 总结 提示：这里对文章进行总结： 例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。 ...
JUC学习笔记 -- (9) ReadWriteLock读写锁的使用
YellowStar的博客
10-24 711
  说到Java并发编程，很多开发第一个想到同时也是经常常用的肯定是Synchronized，但是Synchronized存在明显的一个性能问题就是读与读之间互斥，简言之就是，我们编程想要实现的最好效果是，可以做到读和读互不影响，读和写互斥，写和写互斥，提高读写的效率，这就要用到本章的重点ReadWriteLock读写锁。 之前文章已经介绍了Lock的一种实现ReentrantLock的使用，其...
【JAVA】谈谈 ReadWriteLock 和 StampedLock
AliceNo的博客
01-13 1600
在多线程编程中，对共享资源的读写操作是一个常见的挑战。Java并发包中提供了和两种灵活的锁机制，分别在不同场景下提供了高效的并发控制。深入理解它们的原理、用法以及适用场景，对于提高多线程应用的性能和可维护性至关重要。和为我们在多线程环境中进行读写操作提供了强大的支持。适用于读写操作相对均衡的场景，而则在读多写少的情况下可能更为高效。在实际应用中，根据具体的需求和性能优化目标，选择适合的锁机制是关键。通过深入研究和灵活运用这两种锁机制，希望你能够更加高效地处理多线程编程中的共享资源访问。
Java中读写锁怎么用，并附上代码
06-07
在Java中，读写锁是通过`ReentrantReadWriteLock`类实现的。这个类提供了两个锁，一个读锁和一个写锁，可以通过它们来实现对共享数据的读写操作。 下面是一个简单的示例代码，演示了如何使用读写锁来实现对共享数据的读写操作。 ```java import java.util.concurrent.locks.ReentrantReadWriteLock; public class ReadWriteLockDemo { private static final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); private static int count = 0; public static void main(String[] args) { new Thread(() -> { while (true) { try { lock.writeLock().lock(); count++; System.out.println(Thread.currentThread().getName() + " write count = " + count); Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.writeLock().unlock(); } } }, "write-thread").start(); new Thread(() -> { while (true) { try { lock.readLock().lock(); System.out.println(Thread.currentThread().getName() + " read count = " + count); Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.readLock().unlock(); } } }, "read-thread").start(); } } ``` 在这个例子中，我们创建了一个`ReentrantReadWriteLock`对象作为共享锁，并定义了一个共享变量`count`。然后，我们创建了两个线程，一个写线程和一个读线程。写线程每隔一秒钟增加一次`count`的值，并打印出来，而读线程每隔一秒钟读取`count`的值，并打印出来。 在写线程中，我们使用`lock.writeLock().lock()`获取写锁，并在使用完共享变量后，使用`lock.writeLock().unlock()`释放写锁。而在读线程中，我们使用`lock.readLock().lock()`获取读锁，并在使用完共享变量后，使用`lock.readLock().unlock()`释放读锁。这样就可以保证多个读线程可以同时读取共享变量，而写线程需要独占锁。 需要注意的是，写锁是独占锁，在写锁被持有期间，其他线程无法获取写锁和读锁，而读锁是共享锁，在读锁被持有期间，其他线程可以同时获取读锁，但不能获取写锁。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值