并发编程：ReentrantLock应用

最新推荐文章于 2024-08-07 16:00:21 发布
最新推荐文章于 2024-08-07 16:00:21 发布
阅读量540 收藏 3
点赞数
分类专栏： 并发编程 文章标签： 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40977118/article/details/108594351
版权

ReentrantLock

1. 特点

  1. 可打断，可重入
  2. 可以设置超时时间
  3. 可以设置为公平锁
  4. 支持多个条件变量
  5. 支持读写锁
  • 基本语法
reentrantLock.lock();
try {
    //业务代码
} finally {
    reentrantLock.unlock();
}

2. 重入

package org.example;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.locks.ReentrantLock;

@Slf4j
public class ReEntryLock {
    static ReentrantLock lock = new ReentrantLock();

    public static void lock1() {
        lock.lock();
        try {
            log.info("执行lock1");
        } finally {
            lock.unlock();
        }
    }
    public static void lock2() {
        lock.lock();
        try {
            log.info("执行lock2");
            //重入
            lock1();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        lock2();
    }

}
  • 查看打印

在这里插入图片描述

3. 可打断

t—线程
lock.lockInterruptibly();
标识可以打断
怎么打断
t.interrupt();

package org.example;

import lombok.extern.slf4j.Slf4j;

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

@Slf4j
public class InterruptLock {

    public static void main(String[] args) throws InterruptedException {
        ReentrantLock lock = new ReentrantLock();
        //t1先获取锁，然后睡眠5s
        new Thread(() -> {
            try {
                lock.lock();
                log.info("t1获取锁");
                TimeUnit.SECONDS.sleep(5);
                log.info("t1睡眠了5s");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }

        }, "t1").start();
        TimeUnit.SECONDS.sleep(1);
        //t2加锁失败，因为被t1持有了
        Thread t2 = new Thread(() -> {
            try {
                lock.lockInterruptibly();
                log.info("t2获取锁了，开始执行代码");

            } catch (InterruptedException e) {
                log.info("t2被打断了，没有获取到锁");
            } finally {
                lock.unlock();
            }
        }, "t2");
        t2.start();

        //由于t2可以被打断，所以1s后打断t2，不在等待t1释放锁
        log.info("主线程睡眠1s后打断t2");
        TimeUnit.SECONDS.sleep(2);
        t2.interrupt();
    }

}
  • 查看打印

在这里插入图片描述

4. 超时

lock.tryLock(2, TimeUnit.SECONDS)

package org.example;

import lombok.extern.slf4j.Slf4j;

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

@Slf4j
public class OutTimeLock {
    public static void main(String[] args) throws InterruptedException {
        ReentrantLock lock = new ReentrantLock();
        Thread t1=new Thread(()->{
            log.info("t1启动");
            try {
                //尝试获取锁，如果失败就返回
                if (!lock.tryLock(2, TimeUnit.SECONDS)) {
                    log.info("t1获取锁失败");
                    return;
                }
                try {
                    log.info("t1获得锁");
                } finally {
                    lock.unlock();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t1");

        try {
            lock.lock();
            log.info("主线程获得了锁");
            t1.start();
            TimeUnit.SECONDS.sleep(3);
        } finally {
            lock.unlock();
        }
    }

}
  • 查看打印

在这里插入图片描述

5. 多条件

  • synchronized 中就有条件变量，就是waitSet，不满足条件的线程进入waitSet；而Lock也有waitSet而且有多个

创建条件
Condition waitA = lock.newCondition()
阻塞
waitA.await();
唤醒
waitA.signal();

package org.example;

import lombok.extern.slf4j.Slf4j;

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

@Slf4j
public class MultiConditionLock {

    static ReentrantLock lock = new ReentrantLock();
    static boolean aFlag = false;
    static boolean bFlag = false;

    static Condition waitA = lock.newCondition();
    static Condition waitB = lock.newCondition();

    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            lock.lock();
            try {
                log.info("aFlag="+aFlag);
                while (!aFlag) {
                    log.info("aFlag="+aFlag);
                    try {
                        waitA.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.info("aFlag="+aFlag);
            } finally {
                lock.unlock();
            }
        },"a").start();

        new Thread(()->{
            lock.lock();
            try {
                log.info("bFlag="+bFlag);
                while (!bFlag) {
                    log.info("bFlag="+bFlag);
                    try {
                        waitB.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.info("bFlag="+bFlag);
            } finally {
                lock.unlock();
            }
        },"b").start();

        Thread.sleep(1000);
        new Thread(()->{
            lock.lock();
            try {
                aFlag = true;
                log.info("修改aFlag = true;");
                waitA.signal();
                bFlag = true;
                log.info("修改bFlag = true;");
                waitB.signal();
            } finally {
                lock.unlock();
            }

        }).start();
    }
    
}
  • 查看打印

在这里插入图片描述

6. 读写锁

  • 读写互斥
  • 写写互斥
  • 读读并发

读写锁读锁不支持条件，ReentrantReadWriteLock的 newCondition 会直接exception

在这里插入图片描述

6.1 读写互斥

package org.example;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

@Slf4j
public class ReadWriteLock {

    static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    static Lock r = rwl.readLock();
    static Lock w = rwl.writeLock();

    public static void m(String str) {
        log.info(str);
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        //读
        new Thread(()->{
            log.debug("读锁");
            r.lock();
            try {
                for (int i=0; i < 5; i++) {
                    m("读锁" + i);
                }
            } finally {
                r.unlock();
            }
        },"t1").start();
        //写
        new Thread(()->{
            log.debug("写锁");
            w.lock();
            try {
                for (int i=0; i < 5; i++) {
                    m("写锁" + i);
                }
            } finally {
                w.unlock();
            }
        },"t2").start();
    }

}
  • 查看打印，写锁先获取锁，则先执行写锁业务代码

在这里插入图片描述

  • 读锁先获取锁，则先执行读锁业务代码

在这里插入图片描述

6.2 写写互斥

package org.example;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

@Slf4j
public class ReadWriteLock {

    static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    static Lock r = rwl.readLock();
    static Lock w = rwl.writeLock();

    public static void m(String str) {
        log.info(str);
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        //写
        new Thread(()->{
            log.debug("写锁");
            w.lock();
            try {
                for (int i=0; i < 5; i++) {
                    m("写锁" + i);
                }
            } finally {
                w.unlock();
            }
        },"t1").start();
        //写
        new Thread(()->{
            log.debug("写锁");
            w.lock();
            try {
                for (int i=0; i < 5; i++) {
                    m("写锁" + i);
                }
            } finally {
                w.unlock();
            }
        },"t2").start();
    }

}
  • 查看打印，t2写锁先获取锁，先执行t2线程业务代码

在这里插入图片描述

6.3 读读并发

  • 假设有6个线程，t1正在持有锁，队列内有5个线程（t2–t6）正在等待t1释放锁；
  • 当t1释放锁，按照FIFO的原则依次唤醒队列内的线程；
  • 如果t2是写锁，则t3继续等待，当t2释放锁后，t3获得锁；
  • 如果t3是读锁，那t3会判断t4是不是读锁，如果t4也是读锁，会把t4唤醒，t4唤醒后也会判断t5（假设t5不是读锁）是不是读锁，依此类推，直到后面的锁不是读锁为止，这时t3和t4并发执行；
  • 如果t5是写锁，t6是读锁，t6也只能等到t5释放锁后，再执行；
  • 读读并发指的是连续的读锁可以并发执行。

在这里插入图片描述

package org.example;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

@Slf4j
public class ReadWriteLock {

    static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    static Lock r = rwl.readLock();
    static Lock w = rwl.writeLock();

    public static void m(String str) {
        log.info(str);
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        //读
        new Thread(()->{
            log.debug("读锁");
            r.lock();
            try {
                for (int i=0; i < 5; i++) {
                    m("读锁" + i);
                }
            } finally {
                r.unlock();
            }
        },"t1").start();
        //读
        new Thread(()->{
            log.debug("读锁");
            r.lock();
            try {
                for (int i=0; i < 5; i++) {
                    m("读锁" + i);
                }
            } finally {
                r.unlock();
            }
        },"t2").start();
    }

}
  • 查看打印，t1和t2并发执行

在这里插入图片描述

6.4 读写支持重入，但是只支持降级，不支持升级

  • 先写锁（降级），在读锁
package org.example;

import lombok.extern.slf4j.Slf4j;

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

@Slf4j
public class ReadWriteLock {

    static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    static Lock r = rwl.readLock();
    static Lock w = rwl.writeLock();

    public static void main(String[] args) {
        new Thread(()->{
            try {
                w.lock();
                log.debug("write已经获取");
                r.lock();
                log.debug("read已经获取");
            } finally {
                r.unlock();
                w.unlock();
            }
        },"t1").start();
    }

}
  • 查看打印

在这里插入图片描述

  • 先读锁，在写锁
package org.example;

import lombok.extern.slf4j.Slf4j;

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

@Slf4j
public class ReadWriteLock {

    static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    static Lock r = rwl.readLock();
    static Lock w = rwl.writeLock();

    public static void main(String[] args) {
        new Thread(()->{
            try {
                r.lock();
                log.debug("read已经获取");
                w.lock();
                log.debug("write已经获取");
            } finally {
                w.unlock();
                r.unlock();
            }
        },"t1").start();
    }

}
  • 查看打印，写锁不能获取

在这里插入图片描述

  • 锁升级（先读后写），会发生死锁
  • 假设有2个线程，如果线程t1先获取读锁，这时候线程t2来了，因为读读并发，所以t2也获取读锁；
  • t1继续执行，尝试获取写锁，因为读写互斥，t1一定阻塞，需要等待t2释放读锁，然后t1才能获取写锁，但是t2正常情况下，不会主动释放读锁，所以相互等待。

6.5 缓存场景应用

package org.example;

import lombok.extern.slf4j.Slf4j;

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

@Slf4j
public class ReadWriteLock {

    //缓存变量
    static Object data = "我是缓存中的数据";
    //过期标志，true没过期，直接走缓存；false过期，先查数据库更新缓存，再走缓存
    static volatile boolean cacheValid = false;
    static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    static Lock r = rwl.readLock();
    static Lock w = rwl.writeLock();

    public static void main(String[] args) {
        r.lock();
        //如果缓存过期，则查数据库；没过期，则直接使用data
        if (!cacheValid) {
            //要拿写锁，需要先释放读锁，因为不支持重入升级
            r.unlock();
            //要去load真实数据，set给缓存拿到写锁
            w.lock();
            try {
                //双重校验
                if (!cacheValid) {
                    //更新缓存
                    data = "我是数据库中的数据";
                    cacheValid = true;
                }
                //更新缓存后，需要读取数据，所以加读锁
                r.lock();
            } finally {
                w.unlock();
            }
        }
        try {
            //使用缓存数据
            System.out.println(data);
        } finally {
            r.unlock();
        }
    }
    
}

在这里插入图片描述
在这里插入图片描述

7. Lock与synchronized区别

1、synchronized是Java中的关键字；Lock是jdk中的一个interface接口
2、synchronized修饰的代码在执行异常时，jdk会自动释放锁；Lock发生异常时，需要手动释放，否则会造成死锁，一般都是在finally中
3、synchronize可以用在代码块上，方法上；lock只能写在代码里，不能直接修改方法
4、synchronize是非公平锁；Lock支持公平锁，默认非公平锁
5、synchronize不可中断，只能等待锁的释放；ReentrantLock提供了lockInterruptibly()的打断功能，中断直接抛出异常，可以对打断做出响应
6、synchronized使用Object对象本身的wait、notify、notifyAll调度机制，要么随机唤醒，要么全部唤醒；Lock支撑多条件，可以精准唤醒
7、synchronized是独占锁；ReentrantLock支持读写锁，读锁可以并发，写锁只能独占，还支持锁降级

性能几乎一样，但是在jdk1.8之前，ConcurrentHashMap使用Lock加锁，jdk1.8之后，就换成synchronized，姑且猜测synchronized的性能可能还高于Lock

Fisher3652
关注
专栏目录
多线程系列(九) -ReentrantLock常用方法详解
程序员志哥的博客
02-26 1657
在上一篇文章中，我们介绍了ReentrantLock类的一些基本用法，今天我们重点来介绍一下ReentrantLock其它的常用方法，以便对ReentrantLock类的使用有更深入的理解。
ReentrantLock
热门推荐
噬日者
02-28 1万+
synchronized原语和ReentrantLock在一般情况下没有什么区别，但是在非常复杂的同步应用中，请考虑使用ReentrantLock，特别是遇到下面2种需求的时候。 1.某个线程在等待一个锁的控制权的这段时间需要中断 2.需要分开处理一些wait-notify，ReentrantLock里面的Condition应用，能够控制notify哪个线程 3.具有公平锁功能，每个
Java并发编程(五)—ReetrantLock详解及应用
最新发布
echola_mendes的博客
08-07 1712
synchronized：适用于大多数基本的同步需求，提供了简洁的语法，自动释放锁，适合于简单的同步场景。ReentrantLock：适用于需要更高级特性的场景，如公平锁、超时等待等，需要显式管理锁的获取和释放。如果竞争比较激烈，推荐ReentrantLock去实现，不存在锁升级概念。而synchronized是存在锁升级概念的，如果升级到重量级锁，是不存在锁降级的。
ReentrantLock应用
yanfei464486的博客
01-16 141
package djs.reentrantlock; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class ReentrantLock01 { //ReentrantLock是可重入锁，可冲入锁，某个线程已经获得这把锁，可以再次获得这把锁而不会出现死锁 // ReentrantLock和synchronized 的区别？ //1. R
java ReentrantLock应用
jie310600的博客
09-26 240
[b]java ReentrantLock应用[/b] ReentrantLock可重入锁 1.使用ReentrantLock接口要比使用synchronized关键字效率高一些 [b]不公平锁与公平锁的区别：[/b] [code="java"]private ReentrantLock lock = new ReentrantLock(); //参数默认false，不公平...
并发编程(二十六)-ReentrantLock应用
及时当勉励，岁月不待人
07-02 220
并发编程(二十六)-ReentrantLock应用
Java并发编程：ReentrantLock与读写锁详解
在Java并发编程实践中，第03章深入探讨了Java 5.0引入的高级并发控制机制——重入锁（ReentrantLock）。与传统的内置锁（intrinsic locking）相比，ReentrantLock提供了更为灵活和强大的特性，包括无条件获取、可...
Java并发编程实战：ReentrantLock与读写锁详解
第七章深入探讨Java并发编程实践，重点聚焦于锁机制的...本章内容深入剖析了Java并发编程中的锁机制，尤其关注ReentrantLock及其在性能优化和线程控制方面的优势，对于提高并发应用程序的效率和稳定性具有重要意义。
Java并发编程：深入理解ReentrantLock
在Java并发编程中，ReentrantLock（重入锁）是一个重要的工具，它实现了Lock接口，并且在实际应用中被广泛使用。ReentrantLock的主要特点就是支持重入性和可选择的公平性或非公平性。 一、ReentrantLock的重入性...
深入探究 ReentrantLock 的应用和原理
激流丶的博客
06-25 2081
深入探究 ReentrantLock 的应用和原理
ReentrantLock的原理和应用
limengliang4007的博客
08-19 255
ReentrantLock的构造函数 ReentrantLock() ReentrantLock(boolean fair) 从构造函数可以看出，可以指定是否公平，true构建公平锁，false构建非公平锁。 公平锁：AbstractQueuedSynchronizer.tryAquire()的实现会考虑到等待队列。非公平锁：AbstractQueuedSynchronizer.tr
ReentrantLock使用
mchtnwn的专栏
10-16 913
所谓互斥锁, 指的是一次最多只能有一个线程持有的锁. 在jdk1.5之前, 我们通常使用synchronized机制控制多个线程对共享资源的访问. 而现在, Lock提供了比synchronized机制更广泛的锁定操作, Lock和synchronized机制的主要区别: synchronized机制提供了对与每个对象相关的隐式监视器锁的访问, 并强制所有锁获取和释放均要出现在一个块结构中, 当获取
Lock类-ReentrantLock的使用
weixin_34195142的博客
12-17 127
　　在Java多线程中可以使用synchronized隐式锁实现线程之间同步互斥，Java5中提供了Lock类(显示锁)也可以实现线程间的同步，而且在使用上更加方便。本文主要研究 ReentrantLock的使用。 　　公平锁与非公平锁:公平锁表示线程获取锁的顺序是按照线程加锁的顺序来分配的，即先来先得的FIFO顺序。而非公平锁就是一种获取锁的抢占机制，是随机获得锁的，和公平锁不一样的就是先来的...
Java并发(二):Lock的使用-ReentrantLock类
小东东
05-24 221
现对《Java多线程编程核心技术》中讲述的ReentrantLock类的使用条目，作一下个人总结，内容如下： 一、ReentrantLock-可重入锁 1、实现同步： private Lock lock = new ReentrantLock(); public void runMethod() { lock.lock(); for...
ReentrantLock的使用
weixin_57176230的博客
02-07 3985
（1）synchronized是独占锁，加锁和解锁的过程自动进行，易于操作，但不够灵活。ReentrantLock也是独占锁，加锁和解锁的过程需要手动进行，不易操作，但非常灵活。 （2）synchronized可重入，因为加锁和解锁自动进行，不必担心最后是否释放锁；ReentrantLock也可重入，但加锁和解锁需要手动进行，且次数需一样，否则其他线程无法获得锁。 （3）synchronized不可响应中断，一个线程获取不到锁就一直等着；ReentrantLock可以相应中断。 ReentrantLo
ReentrantLock使用场景和实例
qq_29178991的博客
01-03 1631
转载来源： 使用场景：https://my.oschina.net/noahxiao/blog/101558 实例：http://hyxw5890.iteye.com/blog/1578597 从使用场景的角度出发来介绍对ReentrantLock的使用，相对来说容易理解一些。 可重入概念 若一个程序或子程序可以“安全...
Lock的使用（五）——使用ReentrantLock类
qq_44307209的博客
08-25 358
（3）方法void tryLock(long timeout,TimeUnit unit)的作用是：如果给定线程在等待时间内未被另一个线程保持，且当前线程未被中断，则获取该锁定。（1）方法void lockInterruptibly()的作用是：如果当前线程未被中断，则获取锁定(需要等待别的线程释放锁才行)，如果已被中断则出现异常。该实验使用的是Lock()方法，说明线程B被interrupt中断了，那么执行lock()则不出现异常，正常执行。在默认的情况下，ReentrantLock类使用的是非公平锁。
JDK 5.0 Concurrency Utilities 并发处理（1）ReentrantLock 可重入锁
weixin_34220623的博客
01-24 79
ReentrantLock -- 可重入的锁 可重入锁指在同一个线程中，可以重入的锁。当然，当这个线程获得锁后，其他线程将等待这个锁被释放后，才可以获得这个锁。 构造器：ReentrantLock(boolean fair): 布尔值用来表示，创建的这个锁是公平的锁，还是自由竞争的锁。所谓公平的锁，是指，各个希望获得所得线程获得锁的顺序是按到达的顺序获得，还是自由竞争获得。 通常的使用方...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值