二、Lock 锁—— 2.3 读写锁

原创 已于 2025-08-24 09:34:29 修改 · 224 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言 #JUC

于 2025-08-23 11:17:27 首次发布

不加锁

如果不加锁，任何得到的读写操作是无序的，甚至可能读出来 null 数据。

class Cache {
    Map<String, String> map = new HashMap<>();

    public void put(String key, String value) {
        System.out.println(Thread.currentThread().getName() + " 开始写");
        map.put(key, value);
        System.out.println(Thread.currentThread().getName() + " 写数据: " + value);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    public String get(String key) {
        System.out.println(Thread.currentThread().getName() + " 开始读");
        String value = map.get(key);
        System.out.println(Thread.currentThread().getName() + " 读数据: " + value);
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        return value;
    }
}

public class RWDemo {

    public static void main(String[] args) {
        Cache cache = new Cache();

        for (int i = 0; i < 5; i++) {
            String num = String.valueOf(i);
            new Thread(() -> {
                cache.put(num, num);
            }).start();
        }

        for (int i = 0; i < 5; i++) {
            String num = String.valueOf(i);
            new Thread(() -> {
                cache.get(num);
            }).start();
        }
    }
}

普通 lock 锁

使用普通加锁lock，读操作和写操作都是串行执行，而且写操作全部完成，才会进行读。这是因为 main方法中，先定义了写线程。

写串行保证数据安全，读操作怎么可以串行呢？

class Cache {

    private static final ReentrantLock lock = new ReentrantLock();

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

    public void put(String key, String value) {
        lock.lock();

        try {
            System.out.println(Thread.currentThread().getName() + " 开始写");
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + " 写数据: " + value);
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            lock.unlock();
        }

    }

    public void get(String key) {
        lock.lock();

        try {
            System.out.println(Thread.currentThread().getName() + " 开始读");
            String value = map.get(key);
            System.out.println(Thread.currentThread().getName() + " 读数据: " + value);
            Thread.sleep(200);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            lock.unlock();
        }
    }
}

public class RWDemo {

    public static void main(String[] args) {
        Cache cache = new Cache();

        for (int i = 0; i < 5; i++) {
            String num = String.valueOf(i);
            new Thread(() -> {
                cache.put(num, num);
            }).start();
        }

        for (int i = 0; i < 5; i++) {
            String num = String.valueOf(i);
            new Thread(() -> {
                cache.get(num);
            }).start();
        }
    }
}

读写锁

使用读写锁，写锁串行，但是读并发，瞬间完成了读效果非常好，如下图。

结论：读写锁保证了写操作的原子性，并且可以进行并发读。

class Cache {

    private static final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

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

    public void put(String key, String value) {
        readWriteLock.writeLock().lock();

        try {
            System.out.println(Thread.currentThread().getName() + " 开始写");
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + " 写数据: " + value);
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            readWriteLock.writeLock().unlock();
        }

    }

    public void get(String key) {
        readWriteLock.readLock().lock();

        try {
            System.out.println(Thread.currentThread().getName() + " 开始读");
            String value = map.get(key);
            System.out.println(Thread.currentThread().getName() + " 读数据: " + value);
            Thread.sleep(200);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            readWriteLock.readLock().unlock();
        }
    }
}

public class RWDemo {

    public static void main(String[] args) {
        Cache cache = new Cache();

        for (int i = 0; i < 5; i++) {
            String num = String.valueOf(i);
            new Thread(() -> {
                cache.put(num, num);
            }).start();
        }

        for (int i = 0; i < 5; i++) {
            String num = String.valueOf(i);
            new Thread(() -> {
                cache.get(num);
            }).start();
        }
    }
}

锁饥饿

锁饥饿（Lock Starvation）是指在多线程编程中的一种情况，其中某些线程可能无法获得所需的锁，而一直等待下去，从而无法继续执行，即线程被"饿死"在等待锁的过程中。这可能会导致应用程序的性能问题和不稳定性。

读写锁用不好就会出现锁饥饿。锁饥饿，写操作执行完才进行读，那么读操作就一直在等待，全部等待。

那可不可以，读写交叉并行呢？不是说 写开始 -> 读开始 -> 写结束 -> 读结束这样穿插。

是读写操作独立，但是可以交叉执行两个操作，如图。

只需要修改执行线程的这个步骤，for 循环中允许读线程，也允许写线程。

for (int i = 0; i < 5; i++) {
    String num = String.valueOf(i);
    new Thread(() -> {
        cache.put(num, num);
    }).start();
    //        }
    //
    //        for (int i = 0; i < 5; i++) {
    //            String num = String.valueOf(i);
    new Thread(() -> {
        cache.get(num);
    }).start();
}

锁降级

  • 什么是锁降级呢？
加写锁
写入数据 a = 1
释放写锁

...

加读锁
读取数据 a = 2
释放读锁

问题在于该在释放写锁、获取读锁中间能够有其他的写线程插入，从而影响数据的一致性。影响了我们想要读取到的数据a = 1，如果避免呢？锁降级。

即，先加读锁再释放写锁，就是锁降级。

加写锁
写入数据 a = 1

加读锁
释放写锁

... 这地方无论怎么操作，不能影响 a = 1

读取数据 a = 1
释放读锁

锁降级是一种多线程编程中的一种锁策略，它指的是在持有某个锁的同时，降低该锁的粒度，也就是大粒度锁 -> 小粒度锁。这通常是为了减少锁的竞争，提高程序的并发性能。

锁降级的典型场景是在持有某个写锁时，释放写锁并获取读锁。这样做的好处是在执行读操作期间，其他线程可以同时执行读操作，提高了并发性能。

看到结果就是，读线程读取的数据和写线程写入的数据是完全一样的。

因为我们没法模拟其他线程在中间修改data的一个情形，但是这样一定是对的！

public class RWDemo {

    private static final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    private static Integer data = 0;

    public static int update(Integer newData) {

        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + " 开始写");
            data = newData;
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + " 写数据: " + data);

            // 写操作结束释放锁之前，锁降级开始
            readWriteLock.readLock().lock();

        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            readWriteLock.writeLock().unlock();
        }

        try {
            return get();
        } finally {
            readWriteLock.readLock().unlock();
        }
    }

    public static int get() {
        readWriteLock.readLock().lock();

        try {
            System.out.println(Thread.currentThread().getName() + " 开始读");
            Thread.sleep(200);
            System.out.println(Thread.currentThread().getName() + " 读数据: " + data);

        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            readWriteLock.readLock().unlock();
        }
        return data;
    }

    public static void main(String[] args) {

        new Thread(() -> {
            update(999);
        },"写线程-1").start();

        new Thread(() -> {
            update(666);
        },"写线程-2").start();

        new Thread(() -> {
            get();
        },"读线程-1").start();

        new Thread(() -> {
            get();
        },"读线程-2").start();
    }
}

小结

  1. 支持公平/非公平策略（可以去看源码，支持参数true/false）
  2. 支持可重入

可以理解为就是粒度的转换呗。

是否可重入

再去读锁

再去写锁

获取了读锁

✅

❌

获取了写锁

✅

✅

        3. 支持锁降级，不支持锁升级

粒度大 -> 粒度小 √

粒度小 -> 粒度大 ×

        4. 读写锁如果使用不当，很容易产生“饥饿”问题：

在读线程非常多，写线程很少的情况下，很容易导致写线程“饥饿”，虽然使用“公平”策略可以一定程度上缓解这个问题，但是“公平”策略是以牺牲系统吞吐量为代价的。

Java 高并发编程——锁机制
AI天才研究院
08-03 926
1980年代末，工程师在实验室中进行程序设计时，由于多个CPU、多道程序环境、内存碎片、中断等原因造成程序运行效率低下，而出现了锁（lock）、互斥锁（mutex lock）、条件变量（condition variable）、信号量（semaphore）、读写锁（reader-writer lock）、线程局部存储（thread-local storage）等各种锁机制。为了充分利用多核CPU、提升性能，Java语言从1.5版本开始引入了对锁机制的支持。
MySQL——锁
2301_81283571的博客
04-09 1065
读锁不会阻塞其他客户端的读，但是会阻塞写。写锁及会阻塞其他客户端的读，也会阻塞其他客户端的写对于DML操作插入，删除，查询表中的数据互相兼容，对数据库结构操作失败客户端一：开启事务进行查询语句客户端二：更新数据操作库表：为该库表添加一个字段失败意向共享锁与读锁兼容，与写锁互斥。意向互斥锁与读锁写锁互斥。1.针对索引进行检索时，对已存在的记录进行等值匹配时，将自动优化为行锁2.InnoDB的行锁是针对于索引加的锁不通过索引条件检索数据，那么InnoDB将对表中的所有记录加锁，此时。
七：深入理解 ReentrantReadWriteLock —— 读写锁
sco5282的博客
04-15 817
`ReentrantReadWriteLock`：读写锁。它表示两个锁，一个是读操作相关的锁，称为共享锁；一个是写相关的锁，称为排他锁。适用于**读多写少**的场景（如果用独占锁，效率及其低下），提高并发性能，但也需要更多的内存和处理器时间来维护状态信息
Linux线程间同步 —— 读写锁（reader-writer lock）
electrocrazy的博客
01-09 2364
1 读写锁简介 互斥量要么是加锁状态，要么是不加锁状态，而且一次只有一个线程对其进行加锁。读写锁可以有3种状态：读加锁状态、写加锁状态和不加锁状态。一次只有一个线程可以占有写模式读写锁，但是可以有多个线程同时占有读模式的读写锁。因此读写锁比互斥量具有更高的并行性。 当读写锁处于写加锁状态时，所有试图对这个锁加锁的线程都将被阻塞。当读写锁处于读加锁状态时，所有试图以读模式对这个锁访问的线程都将得
Java笔记——Java的Lock锁
yang1060887552的专栏
10-28 523
1.锁 锁用来控制多线程按照顺序访问临界资源，通常用锁限制同一时间内只有一个线程能访问到临界资源；读写锁对于临界资源的读取操作同一个时间内允许多个线程同时访问，写资源必须互斥执行。 Java提供两种锁 synchronized Lock锁（实现Lock接口的锁） Lock锁的特点 （1）能尝试非阻塞的获取锁； （2）能响应中断，Lock.lockInterruptibly()阻塞等待锁时能响应中断，Lock.lock()不响应中断 （3）能超时获取锁，如果超时会返回，不会一直阻塞等待
sync包——读写锁
点滴生活
10-03 531
官网文档对sync包的介绍： Package sync provides basic synchronization primitives such as mutual exclusion locks. Other than the Once and WaitGroup types, most are intended for use by low-level library routines. Higher-level synchronization is better done via channe
读写锁——ReentrantReadWriteLock原理详解
chuanyingcao2675的博客
07-21 1628
1.读写锁ReentrantReadWriteLock的原理 解决线程安全问题使用ReentrantLock就可以了，但是ReentrantLock是独占锁，某一时刻只有一个线程可以获取该锁，而实际中会有写少读多的场景，显然ReentrantLock满足不了这个需求，所以Reentr...
多线程 —— 锁策略
m0_63191002的博客
05-24 752
锁策略，对于需要实现锁的程序员要重点掌握；对于普通的程序员，工作中很少会被要求实现一把锁，但普通的程序员会常常在代码中使用线程进行 “并发编程”，此时就会涉及到多线程，多线程会涉及到线程安全问题，线程安全问题就需要加锁进行解决。因此对于程序员来说，锁策略的知识点也需要掌握好。死锁：即在多线程或者多进程的环境下，两个或多个线程在执行过程中，由于争夺资源而造成的一种相互等待的现象，如果没有外力干涉，这些线程都将无法执行下去。
JUC基础（三）—— Lock锁 及 AQS
战斧的博客
04-17 2847
我们第一章提到了JUC的几大组成部分，其中就包含了“锁”，实际上Lock锁在业务上的使用频率恐怕是最高的，它弥补了很多synchronized关键字无法顾及的场景，灵活而强大。今天我们就来看一看这个强大的Lock以及它的核心类
MySQL高级篇——锁的概述与案例应用
贝尔摩德苦艾酒
04-24 6366
MySQL高级篇——锁的概述与案例应用
JUC并发编程第十三章——读写锁、邮戳锁
qq_64064246的博客
06-15 820
无锁——>独占锁——>读写锁——>邮戳锁。
8、读写锁ReentrantReadWriteLock&StampLock详解.pdf
02-28
它通过两个独立的锁——读锁和写锁来实现读写分离的目的。 - **读锁**：允许多个线程同时获取，因为读操作通常是非破坏性的。 - **写锁**：独占锁，一次只能被一个线程持有。 #### 2.2 使用示例 ```java private ...
Java锁——AbstractQueuedSynchronizer加锁和解锁分析
泯灭于众生，高歌于孤夜！
02-09 739
在java.util.concurrent.locks包中有很多Lock的实现类，常用的有ReentrantLock、ReadWriteLock（实现类ReentrantReadWriteLock），其实现都依赖java.util.concurrent.AbstractQueuedSynchronizer类，实现思路都大同小异，因此我们以ReentrantLock作为讲解切入点。 1. ReentrantLock的调用过程 经过观察ReentrantLock把所有Lock接口的操作都委派到一个Sync类上，
学习Java24天
最新发布
2401_88987098的博客
08-23 149
（调对象的read）相当于数据输入流（DateIntputstream）写什么打什么（如果要追加需要包低级管道，看第一行）161/199（这几天加把劲把JavaSE学完）（需要读时按照对应顺序的数据类型读数据）IO流（缓冲流和特殊流及io框架）（缓冲字节输入流（包装））（包含缓冲字节输出流）
深入理解 Spring 的 @ControllerAdvice
Roc的博客
08-20 885
简单来说，是一个组件注解（被@Component元注解标注），它允许你将一个类声明为一个全局的、跨多个控制器的增强器（Advice）。你可以把它理解为 Spring MVC 版本的AOP（面向切面编程），但它不是基于代理，而是专门为控制器层设计的。全局异常处理全局数据绑定全局数据预处理命名清晰：类名如，明确其职责。区分使用场景开发，优先使用，专注于返回统一的 JSON 异常响应。开发传统多页应用，使用，可以混合处理异常、绑定模型等。避免过度使用。
java基础知识总结
yvya_的博客
08-19 1790
java 基础包含语法、面向对象，异常处理、文件操作等方面。
Docker容器化部署实战：Tomcat与Nginx服务配置指南
Java
08-22 206
通过Docker快速部署Tomcat和Nginx服务，使用临时容器提取默认配置并挂载到宿主机实现持久化。
Java虚拟机故障处理工具全指南
qq_73993301的博客
08-20 1228
JVM故障处理工具全景指南：从基础到高阶诊断 本文系统介绍了JVM提供的故障诊断工具链，包括命令行工具（jps、jstat、jinfo、jmap、jhat、jstack、jcmd）和可视化工具（jconsole、VisualVM）。详细解析了各工具的核心功能和使用场景：jps用于进程查看、jstat监控GC行为、jmap生成堆转储等。文章提供了实战建议，强调基线数据收集和工具组合使用的重要性，并指出生产环境的使用注意事项。最后还介绍了远程连接、自动化分析等高级技巧，推荐结合Arthas、MAT等专业工具进行
健康常识查询系统|基于java和小程序的健康常识查询系统设计与实现(源码+数据库+文档)
伟庭的博客
08-21 693
本文介绍了一款基于Java和微信小程序的健康常识查询系统设计与实现。系统采用B/S架构，使用MySQL数据库，包含用户端和管理端两大模块。用户可通过小程序查看健康资讯、进行论坛交流、在线咨询及管理健康档案；管理员通过Web端实现用户管理、公告发布等功能。系统设计包含详细的功能结构图、界面展示和ER图，并提供了核心代码示例。该系统旨在为用户提供便捷的健康管理工具，满足现代人对健康信息查询和管理的需求。
实现基于LOCK指令的WINDOWS读写锁封装
因此，我们可以通过参考CRITICAL_SECTION的实现原理，结合CPU提供的LOCK指令，使用C++编程语言来实现一个适用于Windows平台的读写锁。 CRITICAL_SECTION是Windows平台下提供的一种用于同步线程的机制，它实现了一种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值