JUC高并发编程8：读写锁

于 2024-10-09 22:48:22 发布
阅读量602 收藏 14
点赞数 18
分类专栏： Java # JUC 文章标签： java 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gaosw0521/article/details/142797197
版权
Java 同时被 2 个专栏收录
51 篇文章 1 订阅
订阅专栏
JUC
9 篇文章 0 订阅
订阅专栏

1 概述

1.1 悲观锁和乐观锁

在并发编程中，锁机制是用来控制多个线程对共享资源的访问。悲观锁和乐观锁是两种不同的并发控制策略。

1.1.1 悲观锁（Pessimistic Locking）

悲观锁假设在最坏的情况下，多个线程会同时访问和修改共享资源，因此在访问共享资源之前，会先对资源进行加锁，以确保同一时间只有一个线程可以访问该资源。常见的悲观锁实现包括数据库中的表锁和行锁。

  • 优点：可以有效避免数据冲突，适用于写操作较多的场景。
  • 缺点：加锁和解锁操作会增加系统开销，可能导致性能下降。

1.1.2 乐观锁（Optimistic Locking）

乐观锁假设在大多数情况下，多个线程不会同时访问和修改共享资源，因此在访问共享资源时不会立即加锁，而是在提交修改时检查资源是否被其他线程修改过。如果资源被修改过，则回滚操作或重试。常见的乐观锁实现包括版本号机制和时间戳机制。

  • 优点：减少了加锁和解锁的开销，适用于读操作较多的场景。
  • 缺点：在并发冲突较多的情况下，可能会导致频繁的重试操作，影响性能。

1.2 表锁和行锁

在数据库中，锁机制用于控制对表或行的访问。

1.2.1 表锁（Table Lock）

表锁是对整个表进行加锁，当一个事务对表进行加锁后，其他事务无法对该表进行写操作，但可以进行读操作（取决于锁的类型）。

  • 优点：实现简单，不会发生死锁。
  • 缺点：锁的粒度较大，可能会影响并发性能。

1.2.2 行锁（Row Lock）

行锁是对表中的某一行进行加锁，当一个事务对某一行进行加锁后，其他事务无法对该行进行写操作，但可以对其他行进行操作。

  • 优点：锁的粒度较小，可以提高并发性能。
  • 缺点：实现复杂，可能会发生死锁。

1.3 读锁和写锁

在数据库中，锁可以分为读锁和写锁。

1.3.1 读锁（Read Lock）

读锁是一种共享锁（Shared Lock），多个事务可以同时持有读锁，但持有读锁的事务不能进行写操作。读锁不会阻塞其他读锁，但会阻塞写锁。

  • 优点：允许多个事务同时读取数据，提高了并发性能。
  • 缺点：可能会发生死锁，特别是在多个事务同时持有读锁并等待写锁时。

1.3.2 写锁（Write Lock）

写锁是一种独占锁（Exclusive Lock），当一个事务持有写锁时，其他事务不能持有任何锁（包括读锁和写锁）。写锁会阻塞其他所有锁。

  • 优点：可以确保数据的一致性，避免数据冲突。
  • 缺点：可能会发生死锁，特别是在多个事务同时持有写锁并等待其他锁时。

1.4 死锁

死锁是指两个或多个事务在等待对方释放锁的情况下，都无法继续执行的状态。死锁通常发生在以下情况：

  • 读锁和写锁的相互等待：例如，事务1持有读锁并等待事务2释放写锁，而事务2持有写锁并等待事务1释放读锁。
  • 行锁的相互等待：例如，事务1锁定了某一行并等待事务2释放另一行的锁，而事务2锁定了另一行并等待事务1释放第一行的锁。

1.5 小结

  • 悲观锁：适用于写操作较多的场景，通过加锁避免数据冲突，但会增加系统开销。
  • 乐观锁：适用于读操作较多的场景，通过版本号或时间戳机制避免数据冲突，减少加锁开销，但在并发冲突较多时可能导致频繁重试。
  • 表锁：对整个表加锁，实现简单，不会发生死锁，但锁粒度大，影响并发性能。
  • 行锁：对表中的某一行加锁，锁粒度小，提高并发性能，但可能发生死锁。
  • 读锁：允许多个事务同时读取数据，提高并发性能，但可能发生死锁。
  • 写锁：确保数据一致性，避免数据冲突，但可能发生死锁。

2 案例实现

场景: 使用 ReentrantReadWriteLock 对一个 hashmap 进行读和写操作

  • 代码
//资源类
class MyCache{

    // 创建map集合
    private volatile Map<String,Object> map = new HashMap<>();

    // 创建读写锁对象
    private ReadWriteLock rwLock = new ReentrantReadWriteLock();

    // 放数据
    public void put(String key,Object value){
        // 添加写锁
        rwLock.writeLock().lock();




        try {
            System.out.println(Thread.currentThread().getName() +" 正在写操作"+key);
            // 暂停一会儿
            TimeUnit.MICROSECONDS.sleep(300);

            // 放数据
            map.put(key,value);

            System.out.println(Thread.currentThread().getName()+" 写完了" + key);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            // 释放写锁
            rwLock.writeLock().unlock();
        }


    }

    // 取数据
    public Object get(String key){
        // 添加读锁
        rwLock.readLock().lock();
        Object result = null;

        try {

            System.out.println(Thread.currentThread().getName() + " 正在读取操作" + key);
            // 暂停一会儿
            TimeUnit.MICROSECONDS.sleep(300);

            result = map.get(key);
            System.out.println(Thread.currentThread().getName()+" 取完了" + key);

        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            // 释放读锁
            rwLock.readLock().unlock();
        }
        return result;

    }
}
public class ReadWriteLockDemo {
    public static void main(String[] args) throws InterruptedException {
        MyCache myCache = new MyCache();
        // 创建线程放数据
        for (int i = 0; i <= 5; i++) {
            final int num = i;
            new Thread(()->{
                myCache.put(num+"",num+"");

            },String.valueOf(i)).start();
        }

        TimeUnit.MICROSECONDS.sleep(300);

        // 创建线程取数据
        for (int i = 0; i <= 5; i++) {
            final int num = i;
            new Thread(()->{
                myCache.get(num+"");

            },String.valueOf(i)).start();
        }
    }
}

3 读写锁的演变

3.1 读写锁（Read-Write Lock）

读写锁是一种特殊的锁机制，它允许多个读线程同时访问共享资源，但只允许一个写线程访问共享资源。读写锁的主要目的是提高并发性能，特别是在读操作远多于写操作的场景中。

3.1.1 读写锁的特点

  • 读读共享：多个读线程可以同时持有读锁，读操作之间不会互斥。
  • 读写互斥：当一个写线程持有写锁时，其他读线程和写线程都不能访问共享资源。
  • 写写互斥：当一个写线程持有写锁时，其他写线程不能访问共享资源。

3.2 读写锁的演变

3.2.1 无锁

在无锁的情况下，多个线程可以同时访问共享资源，这会导致资源竞争和数据不一致的问题。

public class NoLockExample {
    private int resource = 0;

    public void read() {
        System.out.println("Read: " + resource);
    }

    public void write(int value) {
        resource = value;
        System.out.println("Write: " + resource);
    }
}

3.2.2 添加锁

使用 synchronized 或 ReentrantLock 可以解决资源竞争的问题，但这些锁是独占的，每次只能有一个线程操作资源，即使是读操作也不能共享。

public class SynchronizedLockExample {
    private int resource = 0;

    public synchronized void read() {
        System.out.println("Read: " + resource);
    }

    public synchronized void write(int value) {
        resource = value;
        System.out.println("Write: " + resource);
    }
}

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
    private int resource = 0;
    private Lock lock = new ReentrantLock();

    public void read() {
        lock.lock();
        try {
            System.out.println("Read: " + resource);
        } finally {
            lock.unlock();
        }
    }

    public void write(int value) {
        lock.lock();
        try {
            resource = value;
            System.out.println("Write: " + resource);
        } finally {
            lock.unlock();
        }
    }
}

3.2.3 读写锁

使用 ReentrantReadWriteLock 可以实现读读共享，提高并发性能。

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockExample {
    private int resource = 0;
    private ReadWriteLock rwLock = new ReentrantReadWriteLock();

    public void read() {
        rwLock.readLock().lock();
        try {
            System.out.println("Read: " + resource);
        } finally {
            rwLock.readLock().unlock();
        }
    }

    public void write(int value) {
        rwLock.writeLock().lock();
        try {
            resource = value;
            System.out.println("Write: " + resource);
        } finally {
            rwLock.writeLock().unlock();
        }
    }
}
3.2.3.1 读写锁的缺点
  • 锁饥饿：如果读操作非常频繁，写操作可能会长时间等待，导致写线程饥饿。例如，在地铁系统中，如果一直有人在读取信息（如查看列车时刻表），而没有人进行写操作（如更新列车状态），写操作可能会被长时间阻塞。
  • 读写互斥：读操作在进行时，写操作不能进行，只有读操作完成后，写操作才能进行。这可能会导致写操作的延迟。
  • 写读互斥：写操作在进行时，读操作不能进行，只有写操作完成后，读操作才能进行。这可能会导致读操作的延迟。

4 读写锁的降级

读写锁的降级是指在持有写锁的情况下，获取读锁，然后释放写锁，最后释放读锁的过程。这种操作通常用于在写操作完成后，需要进行读操作的场景。通过锁降级，可以在保证数据一致性的前提下，提高并发性能。

4.1 JDK 8 中的锁降级说明

在 JDK 8 中，读写锁的降级操作可以按照以下步骤进行：

  1. 获取写锁：首先获取写锁，确保当前线程对共享资源有独占访问权限。
  2. 获取读锁：在持有写锁的情况下，获取读锁。
  3. 释放写锁：释放写锁，此时其他线程可以获取写锁，但当前线程仍然持有读锁。
  4. 释放读锁：最后释放读锁，完成整个锁降级过程。

4.2 示例代码

以下是一个使用 ReentrantReadWriteLock 进行锁降级的示例代码：

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockDowngradeExample {
    private int resource = 0;
    private ReadWriteLock rwLock = new ReentrantReadWriteLock();

    public void downgradeLock() {
        rwLock.writeLock().lock(); // 获取写锁
        try {
            // 写操作
            resource = 100;
            System.out.println("Write: " + resource);

            rwLock.readLock().lock(); // 获取读锁
        } finally {
            rwLock.writeLock().unlock(); // 释放写锁
        }

        try {
            // 读操作
            System.out.println("Read: " + resource);
        } finally {
            rwLock.readLock().unlock(); // 释放读锁
        }
    }

    public static void main(String[] args) {
        ReadWriteLockDowngradeExample example = new ReadWriteLockDowngradeExample();
        example.downgradeLock();
    }
}

4.3 读锁不能升级为写锁

需要注意的是，读锁不能直接升级为写锁。如果一个线程持有读锁，并尝试获取写锁，会导致死锁。因为读锁是共享的，多个线程可以同时持有读锁，而写锁是独占的，只能有一个线程持有写锁。如果一个线程持有读锁并尝试获取写锁，而其他线程也持有读锁，就会导致所有线程都在等待对方释放读锁，从而形成死锁。

4.4 小结

  • 锁降级：在持有写锁的情况下，获取读锁，然后释放写锁，最后释放读锁。这种操作可以提高并发性能，特别是在写操作完成后需要进行读操作的场景。
  • 读锁不能升级为写锁：读锁是共享的，写锁是独占的，读锁不能直接升级为写锁，否则会导致死锁。

5 思维导图

在这里插入图片描述

6 参考链接

【【尚硅谷】大厂必备技术之JUC并发编程】

·云扬·
关注
专栏目录
JUC高并发编程从入门到精通（全）
码农研究僧的博客
08-06 1万+
目录前言 前言 在了解这部分内容的时候 先要了解java的一些基础内容 java零基础从入门到精通（全） javaSE从入门到精通（全） 所谓JUC是java.util .concurrent 工具包的简称这是一个处理线程的工具包可以实现多线程高并发的内容 了解该部分内容先了解线程与进程的相关概念 【操作系统】线程与进程的深入剖析（全） java之Thread类详细分析（全） 以及涉及到的lambda表达式函数的概念 java中lambda表达式 ......
初探 JUC 并发编程：读写锁 ReentrantReadWriteLock 原理
kkq的博客
05-10 859
然后去判断当前线程是否应该被阻塞，也就是 AQS 队列的队头是不是请求的写锁，然后去判断最后一个获取到锁的线程是不是本线程，如果不是的话，检查线程中的 readHolds 是否为 0（如果为 0 则说明没有获取到锁，如果获取到了锁这里应该置为 1），因为 get 方法会向线程的 ThreadLocal 中添加对象，所以在确定它没有得到锁之后清楚 ThreadLocal 中的内容。
JUC高并发编程4：集合的线程安全
云扬的博客
09-29 1262
本文是尚硅谷JUC高并发教程中集合的线程安全章节的学习笔记。包括ArrayList线程不安全演示及解决方案、HashSet线程不安全演示及解决方案、HashMap线程不安全及解决方案。供个人学习使用。
JUC(并发编程)
abc98526的博客
04-17 1万+
1.什么是JUC? JUC是指javaUtil包中的三个操作线程的包! 2.线程进程和程序 程序(Program):是一个静态的概念，一般对应于操作系统中的一个可执行的文件 ，比如：我们要启动酷狗听音乐，则对应酷狗可执行程序。当我们双击酷狗，则加载 程序到内存中，开始执行该程序，于是产生了"进程". 进程:执行中的程序叫做进程(Process),是一个动态的概念。现代的操作系统都可以同时启动多个进程。比如:我们在用酷狗听音乐，也可以使用wps写文档，也可以同时用浏览器查看网页。可以通过
高级技术之 JUC 高并发编程
qq_40823822的博客
03-13 311
JUC
【JUC并发编程09】读写锁
为了远大的理想，冲锋！
02-05 1384
文章目录9 读写锁9.1 悲观锁和乐观锁9.2 表锁|行锁|读锁|写锁9.3 读写锁概述9.4 读写锁的演变9.5 锁降级的必要性 9 读写锁 9.1 悲观锁和乐观锁 悲观锁：顾名思义，它是干什么都很悲观，所以在操作的时候，每次都先上锁，使用时解锁 乐观锁：它很乐观，多线程，并不上锁，但是会发生线程安全问题，通过比较版本号来同步 9.2 表锁|行锁|读锁|写锁 表锁：整个表操作，不会发生死锁 行锁：每个表中的单独一行进行加锁，会发生死锁 读锁：共享锁（可以有多个人读），会发生死锁 写锁：独占锁（只能有一个
JUC并发编程——锁
weixin_39555954的博客
12-30 782
锁
JUC并发编程
热门推荐
识时务者的个人博客
07-08 14万+
JUC并发编程 JUC简介 进程、线程的关系 Java默认有两个线程 线程的六种状态 并发、并行的关系： Lock锁 Synchronized 和 Lock的区别 8锁现象 问题一 : 在标准情况下，两个线程先打印 发短信 还是 打电话 ？ 问题二 : 在发短信方法中，延迟4秒，两个线程先打印 发短信 还是 打电话？ 问题三 : Phone类增加一个普通方法，线程B调用，那么两个线程先打印 发短信
JUC高并发编程(13) -- 读写锁
姜皓的博客
05-12 136
读写锁
java并发编程：juc、aqs
08-09
Java并发编程中的`JUC`(Java Util Concurrency)库是Java平台中用于处理多线程问题的核心工具包，它提供了一系列高效、线程安全的工具类，帮助开发者编写并发应用程序。`AQS`(AbstractQueuedSynchronizer)是JUC库中的...
JUC并发编程与源码分析视频课.zip
12-16
《JUC并发编程与源码分析视频课》是一门深入探讨Java并发编程的课程，主要聚焦于Java Util Concurrency（JUC）库的使用和源码解析。JUC是Java平台提供的一组高级并发工具包，它极大地简化了多线程编程，并提供了更...
Java 高并发编程详解：多线程与架构设计
GitChat
12-10 6911
内容简介 本书主要包含四个部分： 部分主要阐述 Thread 的基础知识，详细介绍线程的 API 使用、线程安全、线程间数据通信，以及如何保护共享资源等内容，它是深入学习多线程内容的基础。 第二部分引入了 ClassLoader，这是因为 ClassLoader 与线程不无关系，我们可以通过 synchronized 关键字，或者 Lock 等显式锁的方式在代码的编写阶段对共享资源进行数据一致...
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1211
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JDK1.0主要特性
FoolRabbit的专栏
10-06 356
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 520
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Netty 相比原生IO模型的优势
最新发布
lssffy的博客
10-09 329
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
JAVA开源项目 旅游管理系统 计算机毕业设计
as230627的博客
10-03 1353
旅游管理系统基于Springboot框架、JAVA编程语言、MYSQL数据库开发完成，“操作简单，功能实用”这是本软件设计的核心理念，本系统力求创造最好的用户体验。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值