ReentrantLock + ThreadLocal

最新推荐文章于 2021-08-27 23:56:53 发布
最新推荐文章于 2021-08-27 23:56:53 发布
阅读量163 收藏
点赞数
分类专栏： Java 文章标签： ReentrantLock ThreadLocal
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_wangr/article/details/99555208
版权

ReentrantLock

Synchronized锁

例：

synchronized void m1(){
        for (int i = 0; i < 10; i++) {

            try {
                TimeUnit.SECONDS.sleep(1);//睡1秒
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(i);

        }
    }

    synchronized void m2(){

        System.out.println("m2......");
    }

    public static void main(String[] args) {

        ReentrantLock1 r1 = new ReentrantLock1();
        new Thread(r1 :: m1).start();//开启线程

        try {
            TimeUnit.SECONDS.sleep(1);
        }catch (InterruptedException e){
            e.printStackTrace();
        }

        new Thread(r1 :: m2).start();

    }

上面的例程是使用Synchronized锁，下面将它改写为ReentrantLock

Lock lock = new ReentrantLock();

    void m1(){
        try {
            lock.lock();//相当于synchronized(this)
            for (int i = 0; i < 10; i++) {
                TimeUnit.SECONDS.sleep(1);
                System.out.println(i);
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    void m2(){
        lock.lock();
        System.out.println("m2.....");
        lock.unlock();
    }


    public static void main(String[] args) {

        ReentrantLock2 r2 = new ReentrantLock2();
        new Thread(r2 :: m1).start();
        try {
            TimeUnit.SECONDS.sleep(1);

        }catch (InterruptedException e){
            e.printStackTrace();
        }

        new Thread(r2 :: m2).start();
    }

对比之后发现，ReentrantLock比Synchronized锁多了手动释放的过程

tryLock

tryLock返回一个boolean类型的值，当前线程尝试是否能够得到锁，能够得到返回true，不能得到返回false

 Lock lock = new ReentrantLock();

    void m1(){

        lock.lock();

        try {
            for (int i = 0; i < 100; i++) {
                TimeUnit.SECONDS.sleep(1);
                System.out.println(i);
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }


    void m2(){

        boolean locked = false;

        try {
            locked = lock.tryLock(5,TimeUnit.SECONDS);//尝试看是否能够得到锁(5秒)
            System.out.println(locked ? "拿到锁" : "没有拿到锁");
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            if (locked) lock.unlock();
        }

    }


    public static void main(String[] args) {

        ReentrantLock3 r3 = new ReentrantLock3();

        new Thread(r3 :: m1).start();

        try {
            TimeUnit.SECONDS.sleep(1);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        new Thread(r3 :: m2).start();

    }

lockInterruptibly

当前线程等待其他线程使用完锁，如果其他线程一直在使用锁，会造成程序一直卡住，此时使用lockInterruptibly进行打断

public static void main(String[] args) {


    Lock lock = new ReentrantLock();

    Thread t1 = new Thread(() ->{

        try {

            lock.lock();
            System.out.println("t1 start");
            TimeUnit.SECONDS.sleep(Integer.MAX_VALUE);
            System.out.println("t1 end");

        }catch (InterruptedException e){
            System.out.println("interrupted!");
        }finally {
            lock.unlock();
        }

    });
    t1.start();

    Thread t2 = new Thread(() ->{

        try {
//            lock.lock();
            lock.lockInterruptibly();   //可以对interrupt()方法做出响应
            System.out.println("t2 start");
            TimeUnit.SECONDS.sleep(5);
            System.out.println("t2 end");
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            if(((ReentrantLock) lock).isHeldByCurrentThread()) lock.unlock();
        }

    });
    t2.start();


    try {
        TimeUnit.SECONDS.sleep(1);
    }catch (InterruptedException e){
        e.printStackTrace();
    }

    t2.interrupt(); //打断线程2的等待

    }

设置公平锁

ReentrantLock支持设置公平锁

private static ReentrantLock lock = new ReentrantLock(true);//设置公平锁

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "获得锁");
            }finally {
                lock.unlock();
            }
        }
    }


    public static void main(String[] args) {

        ReentrantLock5 r5 = new ReentrantLock5();

        Thread th1 = new Thread(r5);
        Thread th2 = new Thread(r5);
        th1.start();
        th2.start();

    }

生产者消费者

使用wait和notify实现

public class MyContainer<T>{
    
    final private LinkedList<T> lists = new LinkedList<>();
    final private int MAX = 10;//最多10个元素
    private int count = 0;
    
    
    public synchronized void put(T t){
        
        while(lists.size() == MAX){ //why while not if?
            
            try{
                this.wait(); //容器满了，让生产者线程等待
            }catch(InterruptedException e){
                e,printStackTrace();
            }
            
        }
        
        lists.add(t);
        ++count;
        this.notifyAll();//唤醒所有消费线程
        
    }
    
    
    public synchronized T get(){
        
        while(lists.size() == 0){
            
            try{
                this.wait(); //容器空了，让所有的消费者线程等待
            }catch(InterruptdException e){
                e.printStackTrace();
            }
            
        }
        
        T first = lists.removeFirst();
        count--;
        this.notifyAll();//通知生产者线程进行生产
        
        return first;
    }
    
    
    
    
    public static void main(String[] args){
        
        MyContainer<String> lists = new MyContainer<>();
        //开启消费者线程
        for(int i = 0;i < 10;i++){
            new Thread(()->{
                for(int j = 0;j < 100;j++)
                    System.out.println(lists.get());
            },"c" + i).start();
        }
        
        try{
            TimeUnit.SECONDS.sleep(2);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        
        //开启生产者线程
        for(int i = 0;i < 2;i++){
            
            new Thread(() -> {
                
                for(int j = 0;j < 25;j++)
                    lists.put(Thread.currentThread().getName() + " " + j);
            },"p" + i).start();
        }
        
        
    }
    
    
}

使用Lock和condition实现

public class Container2<T>{
    
    final private LinkedList<T> lists = new LinkedList<>();
    final private int MAX = 10;
    private int count = 0;
    
    private Lock lock = new ReentrantLock();
    private Condition consumer = lock.newCondition();
    private Condition producer = lock.newCondition();
    
    
    public void put(T t){
        
        try{
            lock.lock();
            while(lists.size() == MAX){
                
                producer.await();
            }
            
            lists.add(t);
            ++count;
            consumer.signalAll
        }catch(InterruptedException e){
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
        
    }
    
    
    
    public T get(){
        
        T first = null;
        
        try{
            
            lock.lock();
            while(lists.size() == 0){
                consumer.await();
            }
             T first = lists.removeFirst();
        	count--;
        	producer.signalAll();
            
        }catch(InterruptedException e){
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
        
       
        return first;
    }
    
    
}

ThreadLocal

可以让每个线程的内容独享，其他线程无法使用

synchronized是时间换空间，等到前面的线程执行完后才能执行。

ThreadLocal是空间换时间，每个对象都是独立的

例程：

public class ThreadLocal1 {

    volatile static Person p = new Person();

    public static void main(String[] args) {

        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
            }catch (InterruptedException e){
                e.printStackTrace();
            }

            System.out.println(p.name);
        }).start();

        new Thread(() -> {

            try {
                TimeUnit.SECONDS.sleep(1);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            p.name = "lisi";

        }).start();

    }

}


class Person{

    String name = "zhangsan";
}

public class ThreadLocal2 {

    static ThreadLocal<Person> tl = new ThreadLocal<>();

    public static void main(String[] args) {

        new Thread(() -> {

            try {
                TimeUnit.SECONDS.sleep(2);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(tl.get());

        }).start();


        new Thread(() -> {

            try {

                TimeUnit.SECONDS.sleep(1);

            }catch (InterruptedException e){
                e.printStackTrace();
            }
            tl.set(new Person());
        }).start();


    }

    static class Person{
        String name = "zhangsan";
    }
}
上了发条的小兔叽
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java使用（ThreadLocal、ReentrantLock(JVM锁)、Redisson分布式锁）解决全局共享变量并发安全问题
hkl_Forever的博客
11-10 1023
（当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本）3、此问题可以使用自定义局部变量中转处理解决，也可以使用 ThreadLocal、JVM锁(ReentrantLock)、分布式锁(Redisson) 来解决。2、因为有可能本次线程赋值后还没处理完业务，后续的线程已经把变量值改掉，那么这时候本次线程拿到的就是其他线程赋的值，这个时候会出现并发问题，导致变量值混乱。
ReentrantLock
m0_58186166的博客
10-25 239
1、标题、分类 2、正文 附带源码，版本1.8 零、开头介绍（红涛） 一、简短的对比Synchronized，增加使用场景（吴磊） 二、示例代码，贴合场景（盼盼） 三、源码解读 Lock、ReentrantLock API源码（晓萱） AQS（红涛） CAS思想、问题、在哪用（进福） 四、最终总结：短小精湛的总结（盼盼） ...
Java基础——多线程简述
榴莲男孩的博客
09-24 186
开启多线程的两种方法 继承Thread类 子类继承Thread类（重写run()方法） 启动线程：子类对象.start() 由于Java是单继承，不建议使用继承Thread的方法进行实现多线程 实现Runnable接口 实现Runnable接口（重写run()方法） 启动线程：将该接口的实现类（你正在使用的类）作为参数传入Thread对象后，使用Thread对象.start()进行启动 避免了Java的单继承性，方便同一个对象被多个线程使用的情况 示例： public class Test1
synchronized/volatile/ReentrantLock/ThreadLocal介绍
适恒
03-10 356
1、https://blog.csdn.net/qq_38545713/article/details/80035482 2、https://blog.csdn.net/qq_38545713/article/details/79779163 3、总结一下
synchronized、Lock、ReentrantLock、ReadWriteLock区别，threadlocal怎么解决线程同步问题
一只疯狂的蜗牛
03-20 2677
1.synchronized 用于同步方法和代码块，执行完后自动释放锁2.Lock是一个锁的接口，提供获取锁和解锁的方法(lock,trylock,unlock)3.ReentrantLock 重入锁Lock有一个实现类：ReentrantLock，它实现了Lock里面的方法，但是使用Lock的时候必须注意它不会像synchronized执行完成之后或者抛出异常之后自动释放锁，而是需要你主动释放锁...
ReentrantLock解析
Lynn
10-25 2万+
最近学习Jdk的源代码时，读到了ConcurrentHashMap的源码实现时，发现每一个分段Segment都是ReentrantLock类型，于是顺带对ReentrantLock的源代码进行了学习。。在这里做一个笔记总结。因为只有在工作之余才能有空看看，所以思路有点零散，仅供参考。。。。 1、如何确定哪个线程可重复进入该锁                 在获取锁的时候，首先会检查
多线程中ReentrantLock的使用
ForeverLove的博客
07-17 2173
多线程中ReentrantLock的使用 一.使用ReentrantLock类     在java多线程中，可以使用synchronized关键字来实现线程之间同步互斥，但在jdk1.5中新增了ReentrantLock类也能达到同样的效果，并且在扩展功能上也更加强大，比如具有嗅探锁定，多路分支通知等功能，而且在使用上也比synchronized更加灵活。 1.1使用ReentrantLoc
ThreadPoolRemake.rar
02-03
通过这个改良版的线程池，我们可以学习到如何根据具体场景优化并发设计，理解线程池的工作原理，并掌握如何使用`ReentrantLock`和`ThreadLocal`等工具。同时，这也是一个良好的实践案例，让我们看到了从问题出发，到...
2023年Java面试题+详细总结.docx
01-29
ThreadLocal ThreadLocal 是 Java 中的一种线程变量副本机制，它为每个线程维护一个本地变量。 ThreadLocal 采用空间换时间，用于线程间的数据隔离，为每一个使用该变量的线程提供一个副本，每个线程都可以独立地...
Java多线程 之 临界区、ThreadLocal.docx
06-21
- **使用Lock接口**：Java提供如`ReentrantLock`这样的锁对象，也可以实现线程安全的临界区。相比于`synchronized`，`Lock`提供了更细粒度的控制，如尝试获取锁、可中断锁等待等。 使用临界区的关键在于正确地...
ThreadPoolExecutor源码解析.pdf
11-26
- **ReentrantLock mainLock**：用于在更新内部数据（如线程数量、运行状态、工作线程增减等）时进行同步。 - **Condition termination**：支持awaitTermination方法的等待条件。 - **Worker类**：线程池的核心...
Java学习+面试指南
05-26
1. 线程：线程的创建、同步与通信，如synchronized、wait/notify、ReentrantLock等。 2. Executor框架：ThreadPoolExecutor、Future、Callable接口的理解和使用。 3. 线程安全：volatile、Atomic类、ThreadLocal的...
Synchronized和ThreadLocal的区别
maoyeqiu的专栏
08-09 1628
关于理论知识，以下这两个文章讲的很好： Spring单例与线程安全小结 ThreadLocal的原理和在框架中的应用 不多说，上代码，自己运行一下就知道区别了 package com.spri.test; public class SequenceNumber { public Object obj = new Object(); // ①通过匿名内部类覆盖T
【java基础 14】锁的粒度：ThreadLocal、volatile、Atomic和Synchronized
该怎么解释？我懒得解释
01-07 2345
导读：题目中提到的几个关键字，分别是解决并发问题中，加锁所使用到的几个关键字，每个关键字代表的锁的粒度 不同，本篇博客，主要是从概念定义上，区分这几个关键字的应用场景。（PS：睡梦中，依稀记得有回面试的时候，问了我一个问题：你们在加锁的时候，加多大的锁？ 哇塞，当时愣了一下，压根儿就没有这个大小的概念，我真的以为都是一样的） 话说，就像加锁日记本的锁是个很小的艺术锁，保险箱一般是密码锁（
Java中syncrhoized ,reentrantLock ,Atomic ,Lock ,ThreadLocal ,transient ,volatile，对象锁和类锁
ShareUs的专栏
05-20 1299
 内存的原子性、可见性 &amp; 有序性；  volatile保证可见性 &amp; 有序性，不保证原子性。 -- 工作内存与主内存怎么进行交互？虚拟机定义了8种原子操作： 1.lock（锁定主内存的变量，使其被某一线程独占）， 2.unlock（同理）， 3.read（把一个主内存的变量传递到工作内存中，以便load）， 4.load（将从主内存传递的值传递到工作内存的变量副本中）， 5.s...
Lock锁、ThreadLocal、线程池、
乌昂先生的博客
08-27 211
一、Lock、interface jdk1.5以后 并发包Lock 手动开锁和释放 1、lock(); //开锁 2、lockInterruptibly(); //可中断锁，锁被别人抢到，中断等待 3、tryLock(); boolean //判断有没有被开锁，有就不运行了 4、tryLock(秒); //多长时间内又没有人占用 5、unlock()； //释放锁 .........
ReentrantLock原理
热门推荐
路漫漫，水迢迢
11-04 7万+
ReentrantLock主要利用CAS+AQS队列来实现。它支持公平锁和非公平锁，两者的实现类似。 CAS：Compare and Swap，比较并交换。CAS有3个操作数：内存值V、预期值A、要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。该操作是一个原子操作，被广泛的应用在Java的底层实现中。在Java中，CAS主要是由sun.misc.Unsafe...
多线程的ThreadLocal、ReentrantLock、volatile、Synchronized
weixin_40300139的博客
03-16 262
ThreadLocal：ThreadLocal的作用主要是做数据隔离，填充的数据只属于当前线程，变量的数据对别的线程而言是相对隔离的，在多线程环境下，防止自己的变量被其它线程篡改。 Spring框架里面就是用的ThreadLocal来实现这种隔离，主要是在TransactionSynchronizationManager这个类里面 简单原理：每个线程Thread都维护了自己的threadLocals变量，所以在每个线程创建ThreadLocal的时候，实际上数据是存在自己线程Thread的thread..
聚类算法-一种无监督学习方法.docx
最新发布
08-12
聚类算法是一种无监督学习方法，用于将数据集中的数据点自动分组到不同的类别中，这些类别也称为“簇”或“群”。聚类的目标是让同一簇内的数据点尽可能相似，而不同簇之间的数据点尽可能不相似。聚类算法广泛应用于多种领域，如数据挖掘、模式识别、图像分析、信息检索等。 聚类算法的基本概念 无监督学习：聚类算法不需要事先标记数据点的类别标签，而是根据数据本身的相似性来分组。 相似性度量：聚类算法依赖于某种相似性或距离度量来决定数据点之间的相似程度。常用的度量包括欧氏距离、曼哈顿距离等。 目标函数：大多数聚类算法都会尝试最小化某种目标函数，例如簇内的平方误差和（SSE）。 常见的聚类算法 K-Means K-Means 是一种原型聚类算法，它通过迭代地将数据点分配到最近的质心来形成簇，并重新计算每个簇的质心，直到质心不再显著变化为止。 在 Python 的 scikit-learn 库中，可以通过 KMeans 类实现 K-Means 聚类。 层次聚类 层次聚类构建一个树状图（称为树状图或 dendrogram），显示数据点是如何逐渐合并成簇的。 这种算法可以是凝聚型（自底向上）或分裂型（自顶向下）。
ThreadLocal和AQS
09-21
AQS提供了独占模式（如ReentrantLock）和共享模式（如Semaphore）的同步器实现，并提供了一些方法供子类重写以实现自定义的同步策略。 ThreadLocal和AQS之间没有直接的关系，它们是Java并发包中的两个不同的概念和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值