深度解析Java中的ReadWriteLock：高效处理并发读写操作

2024-01-12 18:12
文章标签 java 高效 深度 并发 处理 解析 读写操作 readwritelock

本文主要是介绍深度解析Java中的ReadWriteLock：高效处理并发读写操作，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

第1章：引言

大家好，我是小黑，今天咱们聊聊读写锁。当多个线程同时对同一数据进行读写操作时，如果没有合理的管理，那数据就乱套了。就好比小黑在写日记，突然来了一帮朋友，大家都想往日记本上写点什么，不加以控制，日记本就成了涂鸦板。

这时，ReadWriteLock就派上用场了。它可以确保当一个线程在写数据时，其他线程要么等待，要么只能执行读操作。这样，即便有多个线程，数据也能保持整洁有序。

为什么选择ReadWriteLock而不是其他类型的锁呢？主要是因为ReadWriteLock允许多个线程同时读取数据，而在写数据时才需要独占。对于读多写少的场景，这就大大提高了效率。想象一下，如果咱们的日记本只允许一个人看，那队伍得排多长啊！

第2章：ReadWriteLock概述

ReadWriteLock，顾名思义，分为读锁（Read Lock）和写锁（Write Lock）。读锁是共享的，多个线程可以同时持有读锁，这就像是多人同时看同一本书。而写锁则是独占的，一旦一个线程获取了写锁，其他线程就只能乖乖等它写完，就像只有一个人能写日记，其他人等着。

来看看ReadWriteLock和其他锁，比如ReentrantLock的区别吧。ReentrantLock是一种排他锁，也就是说，不管是读操作还是写操作，同一时间只能有一个线程访问。而ReadWriteLock则更灵活，允许多个线程同时进行读操作。

现在，咱们用Java代码来展示一下ReadWriteLock的基本使用。代码示例中的变量名和注释都用中文，以便理解。

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;public class ReadWriteLockDemo {private ReadWriteLock rwLock = new ReentrantReadWriteLock();private int value; // 这是小黑要保护的数据public void read() {rwLock.readLock().lock(); // 获取读锁try {System.out.println("小黑正在读取数据：" + value);// 这里模拟读取数据的过程} finally {rwLock.readLock().unlock(); // 释放读锁}}public void write(int newValue) {rwLock.writeLock().lock(); // 获取写锁try {value = newValue;System.out.println("小黑已经更新数据：" + value);// 这里模拟写入数据的过程} finally {rwLock.writeLock().unlock(); // 释放写锁}}
}

在这个示例中，咱们有一个简单的ReadWriteLock实例。当小黑需要读取数据时，它获取读锁；当需要写入数据时，它获取写锁。注意，当一个线程持有写锁时，其他线程既不能读也不能写，确保了数据的一致性和安全性。

第3章：ReadWriteLock的工作机制

读锁的工作原理

读锁是共享的。这意味着多个线程可以同时获得读锁。只要没有线程持有写锁，读锁就可以被无限数量的线程同时获取。这就像图书馆的书，可以被很多人同时阅读，只要没人在修改它。

写锁的工作原理

写锁则完全不同，它是排他的。当一个线程拿到写锁后，其他线程无论是想读还是写，都必须等待。写锁就像小黑的日记本，当小黑在写东西时，别人既不能读也不能写。

锁降级和升级

锁降级是指在持有写锁的同时获取读锁，然后释放写锁的过程。这个过程中，数据不会被其他写操作修改，保证了数据的一致性。锁升级，即从读锁升级到写锁，则在ReadWriteLock中是不被允许的。这是因为允许锁升级会引起死锁。

代码示例

咱们来看一个锁降级的例子。小黑首先写数据，然后在不释放写锁的情况下立即读取，保证了读到的数据是最新的。之后，再释放写锁。

public class LockDowngradeExample {private ReadWriteLock rwLock = new ReentrantReadWriteLock();private int data; // 小黑的数据public void writeData(int newData) {rwLock.writeLock().lock(); // 获取写锁try {data = newData; // 写入数据System.out.println("小黑写入数据: " + data);rwLock.readLock().lock(); // 在不释放写锁的情况下获取读锁} finally {rwLock.writeLock().unlock(); // 释放写锁}try {System.out.println("小黑读取刚写入的数据: " + data); // 读取数据} finally {rwLock.readLock().unlock(); // 释放读锁}}
}

在这个例子中，小黑先获取写锁进行数据写入。在释放写锁之前，他又获取了读锁。这样做的好处是，在释放写锁之后，如果有其他线程等待读锁，小黑仍然能保持对数据的访问。然后，小黑释放了写锁，最后释放读锁。这个过程就是一个典型的锁降级操作。

第4章：ReentrantReadWriteLock

ReentrantReadWriteLock的结构

ReentrantReadWriteLock包含两个主要部分：读锁（ReadLock）和写锁（WriteLock）。这两种锁都实现了Lock接口，但它们的行为截然不同。读锁允许多个线程同时持有，而写锁则是独占的。

ReentrantReadWriteLock的工作原理

当一个线程请求读锁时，如果没有线程持有写锁（或者请求读锁的线程已经持有写锁），它就会获得读锁。相反，当一个线程请求写锁时，只有在没有线程持有读锁或写锁（或者请求写锁的线程已经持有这个写锁）的情况下，它才能获取写锁。

实例代码

让我们通过一个例子来看看ReentrantReadWriteLock是如何工作的。这个例子中，小黑将使用ReentrantReadWriteLock来同步对一个共享资源的访问。

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;public class ReentrantReadWriteLockExample {private ReadWriteLock rwLock = new ReentrantReadWriteLock();private int sharedResource; // 这是一个共享资源public void incrementSharedResource() {rwLock.writeLock().lock(); // 获取写锁try {sharedResource++; // 修改共享资源System.out.println("资源被增加到: " + sharedResource);} finally {rwLock.writeLock().unlock(); // 释放写锁}}public void printSharedResource() {rwLock.readLock().lock(); // 获取读锁try {System.out.println("当前资源值: " + sharedResource); // 读取共享资源} finally {rwLock.readLock().unlock(); // 释放读锁}}
}

在这个例子中，当小黑想要修改共享资源时，他会获取写锁。这样可以保证在他修改资源的时候，没有其他线程能读取或写入资源。而当小黑仅需要读取资源时，他则会获取读锁。由于读锁是共享的，其他线程也可以同时读取资源，但不能写入。

第5章：ReadWriteLock的高级特性

公平性和非公平性

在谈到锁时，公平性是一个重要的概念。公平锁意味着线程获取锁的顺序与它们请求锁的顺序相同。就像在银行排队，先来后到。而非公平锁则可能允许某些线程“插队”，这可能会导致更高的吞吐量，但同时也可能造成线程饥饿。

ReentrantReadWriteLock允许咱们选择公平性或非公平性。默认情况下，它是非公平的，但如果需要，可以在构造时启用公平性。

private ReadWriteLock fairRwLock = new ReentrantReadWriteLock(true); // 创建一个公平的锁
锁的获取和释放的策略

锁的管理是多线程编程中的一个关键环节。获取锁的时机和释放锁的时机都非常重要，需要根据具体的应用场景来决定。

在读多写少的场景中，频繁地获取和释放读锁可能会导致性能下降。相反，在写操作较多的场景中，持有写锁的时间过长则会阻塞读操作，影响整体性能。

代码示例：公平性的应用

让咱们通过一个实例来看看如何使用公平的ReentrantReadWriteLock。在这个例子中，小黑会创建一个公平的读写锁来管理对一个共享资源的访问。

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;public class FairReadWriteLockExample {private ReadWriteLock rwLock = new ReentrantReadWriteLock(true); // 创建一个公平的锁private int sharedData = 0; // 共享数据public void incrementData() {rwLock.writeLock().lock(); // 获取写锁try {sharedData++;System.out.println("数据增加到: " + sharedData);} finally {rwLock.writeLock().unlock(); // 释放写锁}}public void readData() {rwLock.readLock().lock(); // 获取读锁try {System.out.println("当前数据为: " + sharedData);} finally {rwLock.readLock().unlock(); // 释放读锁}}
}

在这个例子中，公平锁确保了所有请求锁的线程都能按顺序获得锁。这对于确保所有线程都能公平地访问资源是很有帮助的。

第6章：ReadWriteLock的使用场景

适合使用ReadWriteLock的场景

  1. 读多写少的场景

    • 当一个应用主要涉及到读取操作，而写操作相对较少时，使用ReadWriteLock非常合适。因为它允许多个线程同时读取数据，从而大大提高了并发性能。这就像图书馆里的一本热门书籍，大家都在阅读，但只有偶尔有人在做笔记。

  2. 数据一致性要求高的场景

    • 在需要确保数据在读取时不被修改的场景中，ReadWriteLock也很适用。它通过写锁来保证在写操作进行时，读操作必须等待，从而保证了数据的一致性。
不适合使用ReadWriteLock的场景

  1. 写操作频繁的场景

    • 如果一个应用中写操作非常频繁，使用ReadWriteLock可能就不是最佳选择了。因为频繁的写操作会导致读操作频繁地等待，从而降低程序的总体性能。

  2. 资源竞争不激烈的场景

    • 在线程间的资源竞争不是很激烈的场景中，使用简单的互斥锁（例如ReentrantLock）可能就足够了。在这种情况下，ReadWriteLock的复杂性可能并不会带来额外的好处。
代码示例：适用ReadWriteLock的场景

让咱们来看一个适合使用ReadWriteLock的场景的代码示例。在这个示例中，小黑将维护一个数据结构，这个数据结构会被多个线程频繁地读取，但写操作相对较少。

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;public class DataStructure {private ReadWriteLock rwLock = new ReentrantReadWriteLock();private int data = 0; // 这是被保护的数据public void readData() {rwLock.readLock().lock(); // 获取读锁try {System.out.println("读取数据: " + data);} finally {rwLock.readLock().unlock(); // 释放读锁}}public void updateData(int newData) {rwLock.writeLock().lock(); // 获取写锁try {data = newData;System.out.println("更新数据为: " + data);} finally {rwLock.writeLock().unlock(); // 释放写锁}}
}

在这个例子中，读操作比写操作频繁得多。因此，使用ReadWriteLock能够在不牺牲数据一致性的前提下，提高程序的读取效率。

第7章：性能考量和最佳实践

性能考量

  1. 读写比例

    • ReadWriteLock最适合于读操作远多于写操作的场景。如果写操作很频繁，那么写锁可能会经常阻塞读锁，从而降低整体性能。

  2. 锁的粒度

    • 锁的粒度是指锁保护数据的大小。粗粒度锁（例如，锁定整个数据结构）可以简化编程模型，但可能降低并发性。细粒度锁（例如，锁定数据结构中的单个元素）可以提高并发性，但编程更复杂，且可能增加死锁的风险。

  3. 锁的公平性

    • 公平锁（即按请求顺序获取锁）可以防止线程饥饿，但可能会降低吞吐量。非公平锁可能提高吞吐量，但有时可能导致线程饥饿。
最佳实践

  1. 减少锁持有时间

    • 获取锁、执行必要的操作然后立即释放锁。这样可以减少锁的争用，提高程序的并发性能。

  2. 避免在持有锁时执行高延迟操作

    • 在持有锁的情况下进行I/O操作、网络通信或其他可能导致线程阻塞的操作，会降低并发性能。

  3. 避免锁嵌套

    • 尽量避免在一个锁内部获取另一个锁，这种做法可能导致死锁和降低性能。
代码示例：性能优化

让咱们看一个优化读写性能的例子。在这个例子中，小黑将采用细粒度锁来提高并发性能。

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;public class FineGrainedLockExample {private ReadWriteLock rwLock = new ReentrantReadWriteLock();private int[] data = new int[10]; // 假设这是一个共享数组public void updateElement(int index, int value) {rwLock.writeLock().lock(); // 获取写锁try {data[index] = value;System.out.println("数据在位置 " + index + " 更新为: " + value);} finally {rwLock.writeLock().unlock(); // 释放写锁}}public int readElement(int index) {rwLock.readLock().lock(); // 获取读锁try {System.out.println("读取位置 " + index + " 的数据: " + data[index]);return data[index];} finally {rwLock.readLock().unlock(); // 释放读锁}}
}

在这个例子中，小黑通过锁定数组的单个元素而不是整个数组，实现了细粒度的锁定。这样，当一个线程在修改数组的某个元素时，其他线程仍然可以访问数组的其他元素，从而提高了并发性能。

第8章：总结

ReadWriteLock是Java中处理并发读写操作的一个强大工具。它通过分离读锁和写锁，允许多线程环境下的高效数据访问。重点在于它允许多个读操作并行进行，而写操作则保持独占，这样既保证了数据的安全性，又提高了程序的性能。

在使用ReadWriteLock时，咱们需要考虑读写比例、锁的粒度和公平性等因素，以确保选择最适合当前场景的策略。记住，没有一种锁是适合所有场景的，了解并根据具体的应用需求选择和使用锁，是至关重要的。

希望这些知识能帮助大家在实际工作中更好地使用ReadWriteLock，写出更高效、更稳定的多线程程序。

这篇关于深度解析Java中的ReadWriteLock：高效处理并发读写操作的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/598735。

相关文章

网页解析 lxml 库--实战

网页解析 lxml 库--实战

lxml库使用流程 lxml 是 Python 的第三方解析库，完全使用 Python 语言编写，它对 XPath表达式提供了良好的支 持，因此能够了高效地解析 HTML/XML 文档。本节讲解如何通过 lxml 库解析 HTML 文档。 pip install lxml lxm| 库提供了一个 etree 模块，该模块专门用来解析 HTML/XML 文档，下面来介绍一下 lxml 库
阅读更多...
JVM 的类初始化机制

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时，有没有考虑过 JVM 是如何把静态的字节码（byte code）转化为运行时对象的呢，这个问题看似简单，但清楚的同学相信也不会太多，这篇文章首先介绍 JVM 类初始化的机制，然后给出几个易出错的实例来分析，帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段，分别是：loading 、Linking、initialization
阅读更多...
Spring Security 基于表达式的权限控制

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权，允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true （Spring security默认会带有ROLE_前缀）,去
阅读更多...
浅析Spring Security认证过程

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程，特意画了如下的类图，包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口，接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti
阅读更多...
Spring Security--Architecture Overview

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类，它们之间的依赖，构建起了整个框架。想要理解整个架构，最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文（security context）的信息。当前操作的用户是谁，该用户是否已经被认证，他拥有哪些角色权限…这些都被保
阅读更多...
Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...
Java架构师知识体认识

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物
阅读更多...
无人叉车3d激光slam多房间建图定位异常处理方案-墙体画线地图切分方案

无人叉车3d激光slam多房间建图定位异常处理方案-墙体画线地图切分方案

墙体画线地图切分方案 针对问题：墙体两侧特征混淆误匹配，导致建图和定位偏差，表现为过门跳变、外月台走歪等 ·解决思路：预期的根治方案IGICP需要较长时间完成上线，先使用切分地图的工程化方案，即墙体两侧切分为不同地图，在某一侧只使用该侧地图进行定位 方案思路 切分原理：切分地图基于关键帧位置，而非点云。 理论基础：光照是直线的，一帧点云必定只能照射到墙的一侧，无法同时照到两侧实践考虑：关
阅读更多...
Java进阶13讲__第12讲_1/2

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2