递归锁(RLock)

最新推荐文章于 2024-06-01 17:38:57 发布
最新推荐文章于 2024-06-01 17:38:57 发布
阅读量2.2k 收藏 4
点赞数 1
文章标签： c/c++
原文链接：http://www.cnblogs.com/xiangjun555/articles/7665768.html
版权
本文探讨了递归锁的概念，通过一个类比解释了为什么普通的锁可能导致死锁，并介绍了递归锁如何解决这个问题。递归锁RLock允许在同一个线程中多次获取锁，每次获取都会在内部计数，释放时相应减少，确保线程能正确解锁。虽然在实际应用中递归锁使用不多，但了解其工作原理对于多线程编程仍然重要。
摘要由CSDN通过智能技术生成
一、概述

 

我们今天来聊聊递归锁，到底什么是递归锁，为什么会存在？

 二、递归锁(RLock)

 

 2.1、前戏

说明：比如你进学校去班级，结果进学校的时候有一道门，进班级的时候又有一道门，你首先进入学校要把第一道门打开，然后锁上。进入学校之后，你又要进班级的门，然后锁上。然后你出班级，就是要打开第二把锁，然后再出校门打开第一把锁。但是这边有一个疑问，就是你在开锁的时候，两把锁的钥匙是一样的，也就是你被困在里面了，出不来了。多重锁把你完美的锁在里面了。代码如下：


 



                

        

        




    




        

            

                    
                      最低0.47元/天 解锁文章
                        
                    
            

        

    

      

        

            

              
                
                  LA7388
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    1
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    4
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
分布式锁:Redisson源码解析——RLock（一）

				
			

			

				

					weixin_47246944的博客
				

				

					11-29
					
					6015
					
				

			

		

		

			
				
分布式锁——Redisson源码篇-加锁（一）初始化锁对象RLock的整体类图CommandAsyncExecutor加锁——ReentrantLock方法重载第一次加锁及watchdog续约重点设计连接发送数据结构watchdog阻塞思考
其实代码整体上可以发现实现可重入锁的方法还是比较简单的，学习成本相对比较低，使用起来也是比较简单的，对于分析可重入锁的部分从下面几个部分来大致的阅读
初始化锁对象
RLock lock = redisson.getLock("anyLock");
RLock的整体类图


			
		

	



                

              
                



	

		

			

				
					
day9-递归锁(RLock)

				
			

			

				

					weixin_33774308的博客
				

				

					08-01
					
					345
					
				

			

		

		

			
				
一、概述
　　我们今天来聊聊递归锁，到底什么是递归锁，为什么会存在？
二、递归锁(RLock)
2.1、前戏
说明：比如你进学校去班级，结果进学校的时候有一道门，进班级的时候又有一道门，你首先进入学校要把第一道门打开，然后锁上。进入学校之后，你又要进班级的门，然后锁上。然后你出班级，就是要打开第二把锁，然后再出校门打开第一把锁。但是这边有一个疑问，就是你在开锁的时候，两把锁的钥匙是一样的，...

			
		

	



                


  
              

                


	

		

			

				
					
C++ Thread多线程并发记录（4）互斥锁，递归锁，超时锁，共享锁

					
最新发布

				
			

			

				

					qq_42761215的博客
				

				

					06-01
					
					833
					
				

			

		

		

			
				
举个例子，一个递归函数，需要被一个线程多次调用，且当前函数中某些临界区需要加锁，如果我们使用常规的mutex等锁进行多次lock()，必然会导致程序异常，此时如果使用递归锁，那么将允许我们多次lock()。有些需要加锁的业务方法，在进行一些业务组合的时候，可能会被调用多次，如果使用常规锁，可能会死锁，比如上一次的加锁还没有解锁，第二次调用的地方又进行加锁，导致死锁，导致程序执行不下去。简单地说，递归锁是一种在锁已被持有的情况下，允许同一线程对该锁进行多次加锁的机制，也叫可重入锁。四.共享锁（读写锁）

			
		

	





	

		

			

				
					
递归锁

				
			

			

				

					dangercheng的专栏
				

				

					07-17
					
					826
					
				

			

		

		

			
				
递归锁在同一线程 内起作用。






[cpp] view
 plaincopy






//线程属性  
#include      
#include      
#include      
pthread_mutex_t g_mutex;  
void test_fun(void);  
static void thread_init(vo

			
		

	



		

			
		



	

		

			

				
					
递归锁（可重入锁）

					
热门推荐

				
			

			

				

					愤怒的菜鸟
				

				

					09-24
					
					1万+
					
				

			

		

		

			
				
近日在调试一个线程挂起的BUG，究其原因是该用递归锁的地方使用了普通的互斥锁，导致了死锁。
  趁着这个机会也好好了解了一下很少用到的递归锁。
  所谓递归锁，就是在同一线程上该锁是可重入的，对于不同线程则相当于普通的互斥锁。
  例如：有互斥量LOCK
  func A （） {  
     LOCK.lock();
     B();
    LOCK.unlock();

			
		

	





	

		

			

				
					
关于递归锁

				
			

			

				

					lanseshenhua的专栏
				

				

					04-24
					
					4009
					
				

			

		

		

			
				
递归锁在同一线程内起作用。//线程属性#include    #include    #include    pthread_mutex_t g_mutex;void test_fun(void);static void thread_init(void){	//初始化锁的属性	pthread_mutexattr_t attr;	pt

			
		

	





	

		

			

				
					
Python多线程操作之互斥锁、递归锁、信号量、事件实例详解

				
			

			

				

					09-17
				

			

		

		

			
				
在Python中，我们使用`threading.RLock()`创建递归锁。与互斥锁不同，递归锁在同一个线程内多次调用`acquire()`不会阻塞，只有当同一线程调用相同次数的`release()`后，锁才会被真正释放。这样可以防止因锁的不当...

			
		

	





	

		

			

				
					
Python多线程编程（六）：可重入锁RLock

				
			

			

				

					09-22
				

			

		

		

			
				
使用RLock的一个关键好处是它可以防止意外的死锁，特别是在编写递归函数或在锁保护的代码块内部调用其他可能也需要锁的函数时。例如，假设有一个函数在临界区调用了另一个需要锁的函数，如果没有使用可重入锁，那么...

			
		

	





	

		

			

				
					
python线程中同步锁详解

				
			

			

				

					09-20
				

			

		

		

			
				
 - **特点**：与互斥锁不同，可重入锁允许一个线程在已经持有锁的情况下再次获取该锁，这在递归调用中非常有用，防止出现死锁。  - **工作原理**：RLock维护一个线程拥有权和递归级别的计数器。每次调用`acquire()`...

			
		

	





	

		

			

				
					
浅谈python锁与死锁问题

				
			

			

				

					09-16
				

			

		

		

			
				
这在需要递归访问锁保护的资源时非常有用。  ```python import threading  class PurchaseRequest:  def __init__(self, initial_value=0):  self._value = initial_value  # 使用可重入锁  self._lock = threading....

			
		

	





	

		

			

				
					
python 锁的使用 python锁的使用例程python2可以直接运行，提供示例程序，供学习参考

				
			

			

				

					08-18
				

			

		

		

			
				
Python 的 `threading.RLock` 是为了防止递归锁死锁而设计的，通常更安全。  总结：锁是一种同步原语，用于控制对共享资源的访问，防止并发执行带来的问题。  多线程的同步  在多线程环境下，当多个线程试图访问同一...

			
		

	





	

		

			

				
					
递归锁有什么用？

				
			

			

				

					
				

				

					08-19
					
					1142
					
				

			

		

		

			
				
当一个已经拥有锁的线程试图再次获取该锁时，若不阻塞则称锁为递归的。为什么要有这样的特性呢？为什么一个线程会试图锁定一个它已经锁住的东西呢？典型的情况是一个线程锁定一个资源，然后调用一个更低的子例程在它上面操作。而这个低层例程也可能被那些高层的，但并未锁住资源的例程调用。因此低层例程并不知道资源是否被锁住。若它试图锁住资源，会出现单进程死锁。

			
		

	





	

		

			

				
					
学习笔记 | 递归锁?

				
			

			

				

					大虎牙的博客
				

				

					08-27
					
					524
					
				

			

		

		

			
				
递归锁?


线程同步能够保证多个线程安全访问竞争资源，最简单的同步机制是引入互斥锁。 互斥锁为资源引入一个状态:锁定/非锁定。某个线程要更改共享数据时，先将其锁定， 此时资源的状态为“锁定”，其他线程不能更改; 直到该线程释放资源，将资源的状态 变成“非锁定”，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。


读写锁从广义的逻辑上讲，也可以认为是一种共享版的互斥锁。如果对一个临界区大部分是读操作而只有少量的写操作，读写锁在一定程度上能够降低线

			
		

	





	

		

			

				
					
Python多线程——递归锁RLOCK

				
			

			

				

					KK_2018的技术博客_程序员不止是程序员
				

				

					02-02
					
					333
					
				

			

		

		

			
				
# with——自动打开自动关闭
import threading
import time

class Test:
    rlock=threading.RLock()
    def __init__(self):
        self.number=0

    def execute(self,n):
        with Test.rlock:
            self.number+=n

    def add(self):
        with Test.rlock:.

			
		

	





	

		

			

				
					
c++ 递归锁

				
			

			

				

					hyl999的专栏
				

				

					03-30
					
					5449
					
				

			

		

		

			
				
递归锁RECURSIVE_MUTEX的原理以及使用

标签：Multi_ThreadRecursive_Mutex

递归锁的作用


MutexLock mutex;  

void foo()  
{  
    mutex.lock();  
    // do something  
    mutex.unlock();  
}  

void bar()  
{  
    mutex.lock();  
    // do something  
    foo();  
    mut...

			
		

	





	

		

			

				
					
可重入锁(递归锁)

				
			

			

				

					我的博客
				

				

					09-16
					
					3107
					
				

			

		

		

			
				
可重入锁
synchronized 和Lock都是可重入锁，也叫递归锁，即一个线程可以重复获取同一把锁
是指在同一个线程在外层方法获取锁的时候，再进入该线程的内层方法会自动获取锁(前提，锁对象得是同一个对象)，不会因为之前已经获取过还没释放而阻塞。
Java中ReentrantLock和synchronized都是可重入锁，可重入锁的一个优点是可一定程度避免死锁。
synchronized 是隐式锁，Lock是显式锁
即synchronized 加锁解锁自动完成
Lock加锁解锁要手动完成
synchron

			
		

	





	

		

			

				
					
python  -- 递归锁

				
			

			

				

					weixin_43345943的博客
				

				

					10-06
					
					477
					
				

			

		

		

			
				
python – 递归锁
假设创建两个锁A,B
并执行DIgui_clock（）


分别执行def A(),def B()。
当第一个线程执行完A()后，释放A,B锁，进入B()。
此时第二个线程开始执行A()。
则当第一个和第二线程分别执行到16，7行时，因无法获得另一个锁。
（第一个：有B锁无A锁
第二个：有A锁无B锁）
此时线程将会卡死，为死锁。

解决方法：
使用递归锁：threadin...

			
		

	





	

		

			

				
					
python 递归锁

				
			

			

				

					ljwy1234的博客
				

				

					01-26
					
					616
					
				

			

		

		

			
				
递归锁 其实就是维护一个计数器 比如A 线程 获得了锁 那么计数器会+1  释放的时候 为0  如果这个计数器不为0  那么其他的线程无法获得锁 只能慢慢的等待

 


import  threading
import time


class MyThread(threading.Thread):

    def actionA(self):

        r_lcok.acquire(...

			
		

	





	

		

			

				
					
python实现递归互斥锁

				
			

			

				

					04-26
				

			

		

		

			
				
Python 实现递归互斥锁可以使用 threading 库中的 RLock 类。 RLock 是一种可重入锁，它允许同一线程在没有完全释放锁的情况下再次获得这个锁。  下面是一个简单的代码示例：  ``` import threading  # 创建一个可重...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值