ReentrantLock锁的一种误用分析

最新推荐文章于 2024-07-18 13:36:41 发布
最新推荐文章于 2024-07-18 13:36:41 发布
阅读量2.2k 收藏 2
点赞数 1
分类专栏： JavaApp 文章标签： java 锁 ReentrantLock
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hongweigg/article/details/78126984
版权

在网上看到一个兄弟写的关于ReentrantLock的文章，介绍得挺详细的，但是有个例子却讲得有点问题。看下面的代码：

import java.util.concurrent.locks.ReentrantLock;  
  
public class ReentrantLockPractice3 {  
  
    static ReentrantLock lock = new ReentrantLock();  
    private static String[] threadArr = {"A","B","C"};  
      
    public static void main(String[] args){  
        ReentrantLockPractice3 pc = new ReentrantLockPractice3();  
        pc.startDemo();  
    }  
      
    void startDemo(){  
        for(int i = 0;i<10;i++){  
            for(String name : threadArr){  
                TestThread t = new TestThread(name);  
                t.start();  
                try {  
                    Thread.sleep(100);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
    }  
      
  
    class TestThread extends Thread{  
          
        //自定义线程名字  
        TestThread(String str){  
            super(str);           
        }  
          
        public void run(){  
            try {  
                lock.lockInterruptibly();
                System.out.println( Thread.currentThread().getName());                  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            } finally{  
                lock.unlock();  
            }     
        }  
    }  
      
}

输出结果：

ABCABCABCABCABCABCABCABCABCABC

在这个例子中，作者的意图是通过ReentrantLock来保证多线程输出的有序性：

三个线程，线程名分别为A、B、C，设计程序使得三个线程循环打印“ABC”10次后终止。如：ABCABCABCABCABCABCABCABCABCABC

也许作者对ReentrantLock比较了解，但这个例子却是和ReentrantLock没有什么关系，也就是说，ReentrantLock锁在这里没有起到应有的作用。把ReentrantLock锁去掉，依然能够有序地输出。 

 
public class ReentrantLockPractice3a {  
 
    private static String[] threadArr = {"A","B","C"};  
      
    public static void main(String[] args){  
        ReentrantLockPractice3a pc = new ReentrantLockPractice3a();  
        pc.startDemo();  
    }  
      
    void startDemo(){  
        for(int i = 0;i<10;i++){  
            for(String name : threadArr){  
                TestThread t = new TestThread(name);  
                t.start();  
                try {  
                    Thread.sleep(1);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
    }  
      
  
    class TestThread extends Thread{  
          
        //自定义线程名字  
        TestThread(String str){  
            super(str);           
        }  
          
        public void run(){  
            try {
 
                System.out.print(Thread.currentThread().getName());  
                
            } catch(Exception e){  
               e.printStackTrace();
            }     
        }  
    }  
      
}

输出结果：

ABCABCABCABCABCABCABCABCABCABC

结果仍然是有序的ABCABC...序列，这是为什么呢？

其实真正起让输出有序的是这几行代码：

                try {  
                    Thread.sleep(100);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }
    线程每次start后，延时100ms，这让线程有足够的时间进行排队，也就是说，正是因为这个延迟，让原本乱序执行的线程，变得有序起来，即便将延时修改为1ms，也能取得同样的执行效果。因此，ReentrantLock锁在此没有起到应有的作用。

    作者举的这个例子，从目的上讲，是要用到多线程快速处理，并且要让输出的线程有序，实际上的效果是线程都是顺序执行的，也就是说，与使用单线程没有两样，反而增加了创建线程的开销。

    实际上，用到锁，必然涉及到资源的争用，如果不涉及到资源的争用，用锁就没有意义了。为了解释ReentrantLock，可以创建一个资源争用的例子，让锁真正发挥作用：当然也一定会用到多线程，多线程的作用是提高处理效率，其乱序执行是允许的，我们真正要关心的是处理好要顺序执行的变量。看下面的例子：

import java.util.concurrent.locks.ReentrantLock;  
  
public class ReentrantLockPractice3b {  
	
	public int counter = 0;

    static ReentrantLock lock = new ReentrantLock();  
    private static String[] threadArr = {"A","B","C"};  
      
    public static void main(String[] args){  
        ReentrantLockPractice3b pc = new ReentrantLockPractice3b();  
        pc.startDemo();  
    }  
      
    void startDemo(){
    	
        for(int i = 0;i<10;i++){  
            for(String name : threadArr){  
                TestThread t = new TestThread(name, this);  
                t.start();  
            }  
        }  
    }  
      
  
    class TestThread extends Thread{  
    	
    	ReentrantLockPractice3b rl2;
 
        //自定义线程名字  
        TestThread(String str, ReentrantLockPractice3b rl2){  
            super(str);      
            this.rl2 = rl2;
        }  
          
        public void run(){  
            try {  
                lock.lockInterruptibly();

            	System.out.println("counter:" + rl2.counter++);
//              try {
//		    sleep(1000);
//		} catch (InterruptedException e) {
//		    e.printStackTrace();
//		}
                
                System.out.println( Thread.currentThread().getName() );  
                
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            } finally{  
                lock.unlock();  
            }     
        }  
    }  
      
}

在这个例子中，我们构造了一个会引起资源争用的变量(counter)，我们的目的是保证其有序访问。看下面的输出结果：

counter:0
A
counter:1
C
counter:2
C
counter:3
A
counter:4
A
counter:5
B
counter:6
B
counter:7
B
counter:8
C
counter:9
A
counter:10
A
counter:11
C
counter:12
A
counter:13
B
counter:14
B
counter:15
C
counter:16
A
counter:17
C
counter:18
A
counter:19
B
counter:20
C
counter:21
B
counter:22
B
counter:23
C
counter:24
C
counter:25
A
counter:26
B
counter:27
C
counter:28
A
counter:29
B
可以看到，通过ReentrantLock，保证了counter的有序，但是线程的启动并不是按设想的“ABCABC...”的方式执行的，而是无序的，这正是虚拟机高效调度的体现。如果限定了线程的依次执行，那不就等同于单线程了吗？

可以看看，去掉ReentrantLock后，结果会变成什么样子：

import java.util.concurrent.locks.ReentrantLock;  
  
public class ReentrantLockPractice3b {  
	
	public int counter = 0;

    static ReentrantLock lock = new ReentrantLock();  
    private static String[] threadArr = {"A","B","C"};  
      
    public static void main(String[] args){  
        ReentrantLockPractice3b pc = new ReentrantLockPractice3b();  
        pc.startDemo();  
    }  
      
    void startDemo(){
    	
        for(int i = 0;i<10;i++){  
            for(String name : threadArr){  
                TestThread t = new TestThread(name, this);  
                t.start();  
            }  
        }  
    }  
      
  
    class TestThread extends Thread{  
    	
    	ReentrantLockPractice3b rl2;
 
        //自定义线程名字  
        TestThread(String str, ReentrantLockPractice3b rl2){  
            super(str);      
            this.rl2 = rl2;
        }  
          
        public void run(){  
            try {  
                //lock.lockInterruptibly();

            	System.out.println("counter:" + rl2.counter++);
//              try {
//		    sleep(1000);
//		} catch (InterruptedException e) {
//	            e.printStackTrace();
//		}
                
                System.out.println( Thread.currentThread().getName() );  
                
            } /*catch (InterruptedException e) {  
                e.printStackTrace();  
            } */finally{  
                //lock.unlock();  
            }     
        }  
    }  
      
}

输出结果：

counter:0
counter:3
A
counter:4
B
counter:2
B
counter:6
C
counter:7
A
counter:1
C
counter:5
B
A
counter:8
counter:9
C
A
counter:11
counter:10
B
counter:13
C
counter:14
B
counter:16
A
counter:12
B
counter:17
A
counter:19
C
counter:15
A
counter:22
C
counter:24
C
counter:25
counter:21
C
counter:20
counter:18
B
counter:27
B
B
A
counter:26
B
C
counter:23
A
counter:28
A
counter:29
C
可以看到，counter的值是混乱的，没有按照预设的目标进行计数。ReentrantLock锁发挥了作用。

其实，这里的lock.lockInterruptibly();用lock.lock();更合适一些，因为这里不涉及到锁的中断。

注意：

使用ReentrantLock锁，一定要在finally代码块中进行解锁，否则，会跟同步造成的死锁一样，出现锁一直等待的情形。



hongweigg
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
reentrantlock失效了?_ReentrantLock 源码简单分析
weixin_30482277的博客
01-09 980
JAVA中锁的实现最常见的方式有两种，一种是 synchronized关键字，一种是Lock。实际的开发过程中，要对这两种方式进行取舍。 synchronized是基于JVM层面实现的， Lock却是基于JDK实现的。synchronized是一个关键字，使用简单，锁粒度粗。Lock相对复杂，需要释放，锁粒度自由。Lock 功能相对强大，如下表。下面开始正文，ReentrantLock 是Loc...
ReentrantLock,多线程并发修改一个数据，结果重复数据，锁没有起作用,why?
liuji0517的博客
02-29 886
importjava.util.concurrent.locks.Lock; importjava.util.concurrent.locks.ReentrantLock; publicclassSynchronizedThread{ publicvoiduseThread()throwsInterruptedException{ finalBank...
java多线程学习8-显示锁Lock和ReentrantLock
u014574478的专栏
04-10 375
Lock是一个提供了锁获取的操作接口，实现的类有ReentrantLock和ReadLock,WriteLock。 先看一个例子，在count类的两个方法中分别用两个锁 package com.cwj.test410; import java.util.concurrent.locks.ReentrantLock; public class ReentrantLockDemo { pub
ReentrantLock 中的 4 个坑
2401_84814482的博客
05-13 511
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
慎用ReentrantLock
donlian的专栏
07-21 214
前言： 代码简洁与性能高效无法两全其美，本文章专注于并发程序的性能，如果您追求代码简洁，本文章可能不太适合，本文章属于Java Concurrency in Practice读书笔记。 在java5中，新增加ReentrantLock提供了一种比synchronized更为灵活的锁机制。为啥说灵活，而不是说性能更高呢？ReentrantLock提供的锁功能跟synchronized的功能基...
Java高并发之JVM本地锁ReentrantLock、synchronized及失效场景
Meta39的博客
11-22 748
Java高并发之JVM本地锁ReentrantLock、synchronized及失效场景
Java多线程 ReentrantLock互斥锁详解
08-25
ReentrantLock是Java多线程编程中的一种锁机制，它可以实现线程之间的同步访问资源。ReentrantLock的主要特点是可以重入，即一个线程可以多次获得锁，而不需要释放锁。这种机制可以避免死锁的出现。 ReentrantLock...
ReentrantLock源码详解--条件锁
08-25
ReentrantLock源码详解中最重要的一个部分就是条件锁，条件锁是指在获取锁之后发现当前业务场景自己无法处理，而需要等待某个条件的出现才可以继续处理时使用的一种锁。今天我们来详细介绍条件锁的原理和实现。 ...
ReentrantLock源码详解--公平锁、非公平锁
08-25
ReentrantLock是一种重入锁，实现了Lock接口，能够对共享资源重复加锁，即当前线程获取该锁再次获取不会被阻塞。ReentrantLock的可重入性是通过继承AQS（AbstractQueuedSynchronizer）实现的。 ReentrantLock的主要...
教你完全理解ReentrantLock重入锁
10-16
ReentrantLock是Java中的一种高级锁，它实现了Lock接口，提供比synchronized更精细的锁控制。ReentrantLock支持重入性，意味着一个线程可以多次进入同一段被该锁保护的代码，只要这个线程还没有释放这个锁。这种特性...
Java并发编程之显示锁ReentrantLock和ReadWriteLock读写锁
09-03
ReentrantLock是一个可重入的锁，这意味着一个线程可以多次获取同一锁，这与synchronized内置锁的行为相同。然而，与内置锁不同的是，使用ReentrantLock需要显式调用`lock()`和`unlock()`方法来获取和释放锁，这增加...
mysql 锁不起作用_java,lock_ReentrantLock锁不起作用，java,lock,mysql - phpStudy
weixin_33501543的博客
02-10 325
ReentrantLock锁不起作用插入数据之前需要先检查数据库中没有了才插入，没加锁之前发现如果两次添加请求很接近会出现重复插入情况，所以添加了一个ReentrantLock锁，但是实际使用发现还是会出现重复插入。锁添加在Spring 的 Controller 里：@RestController@RequestMapping("/user")public class UserAction {Lo...
【Java】@Transactional事务套着ReentrantLock锁，锁竟然失效超卖了
最新发布
JavaDog程序狗
07-18 738
本文聚焦于Java并发编程中常见的超卖问题，这是一种由于并发操作不当而导致的数据一致性错误。文章通过生动的案例——空调租赁充值时长的并发操作——引出了超卖现象及其影响。随后，介绍了四种解决超卖问题的策略：乐观锁、悲观锁、分布式锁和代码级锁（如ReentrantLock）。特别强调了在使用锁机制时，事务边界管理的重要性，指出锁的获取和释放应严格控制在事务范围内，以确保数据在高并发场景下的完整性和一致性。通过合理的事务边界设置和锁管理，可以有效避免超卖问题，提升系统的可靠性和性能。
用JVM本地锁解决并发问题 并分析导致锁失效的原因
weixin_37559642的博客
02-15 202
用JVM本地锁解决并发问题 并分析导致锁失效的原因
ReentrantLock问题记录
程序员的博客
03-21 1026
说ReentrantLock前我们先了解一下Lock与AbstractQueuedSynchronizer(AQS)，Doug Lea大师为我们提供了大量实用，高性能的工具类，这些代码在java.util.concurrent包下。包的结构大概是： lock简介 我们下来看concurent包下的lock子包。锁是用来控制多个线程访问共享资源的方式，一般来说，一个锁能够防止多个线程同时访问共享...
ReentrantLock 详解
weixin_30697239的博客
02-19 94
ReentrantLock的功能是实现代码段的并发访问控制，也就是通常意义上所说的锁，java中实现锁有两种方式，一种是本文所提的ReentrantLock，另一种是synchronized。ReentrantLock相比synchronized 使用可以更灵活，这次就来看看ReentrantLock的内部实现。 我们首先看下ReentrantLock的锁是如何实现的 其实就一行代码 ，看...
ReentrantLock详解
GitYang的博客
09-17 183
ReentrantLock实现方式与Synchronized实现方式对比 1.ReentrantLock实现 public static void main(String[] args) { ReentrantLock lock = new ReentrantLock(); Thread t1 = new Thread(new Runnable() { @Ove...
详述重入锁-ReentrantLock
Java框架、并发编程、分布式、微服务、Redis、HarmonyOS、中间件等技术
06-22 464
有经典，有干货，微信搜索【李子捌】关注这个每日更新的程序员。 简介 重入锁ReentrantLock指的是支持同一个线程对资源的重复加锁。ReentrantLock中有公平锁和非公平锁的两种实现。 synchronized synchronized关键字支持隐式的重入；当一个线程获取到锁时，是支持这个线程多次获取这个锁的，不会出现自己阻塞自己的情况，并且我们开发过程中对于synchronized关键字也不需要关心锁的释放。举个递归的例子我们来看synchronized关键字对锁的重入。 代码示.
ReentrantLock锁面试题
02-23
ReentrantLock是Java中的一个可重入锁，它提供了与synchronized关键字类似的功能，但更加灵活和强大。下面是一些与ReentrantLock锁相关的面试题及其答案： 1. 什么是可重入锁？ 可重入锁是指同一个线程可以多次获得同一个锁，而不会造成死锁。ReentrantLock就是一个可重入锁。 2. ReentrantLock相对于synchronized关键字有什么优势？ 相对于synchronized关键字，ReentrantLock提供了更多的功能和灵活性。它可以实现公平锁和非公平锁，支持多个条件变量，可以中断等待锁的线程，还可以尝试获取锁等。 3. ReentrantLock如何实现可重入性？ ReentrantLock通过记录持有锁的线程和持有次数来实现可重入性。当一个线程再次获取已经持有的锁时，它的持有次数会增加，当释放锁时，持有次数会减少，只有当持有次数为0时，其他线程才能获取该锁。 4. ReentrantLock如何实现公平性和非公平性？ ReentrantLock可以通过构造函数来指定是公平锁还是非公平锁。公平锁会按照线程请求的顺序来获取锁，而非公平锁则允许插队，可能会导致某些线程一直获取不到锁。 5. ReentrantLock如何实现条件变量？ ReentrantLock提供了Condition接口来支持条件变量。通过调用ReentrantLock的newCondition()方法可以创建一个Condition对象，然后可以使用该对象的await()、signal()和signalAll()方法来实现线程的等待和唤醒。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值