python之递归锁【Rlock】

# 递归锁:就是一把锁中还有一把小锁,比如学校的大门口有一个大锁,学校里的
#每个教室也有一把小锁,以后所有的锁都用rlock就可以了,不要用lock,尤其是多层锁的时候,必须要用递归锁
import threading
import time

def run1():
    print("grab the first part data")
    lock.acquire()
    global num1
    num1 += 1
    lock.release()
    return num1

def run2():
    print("grab the second part data")
    lock.acquire()
    global num2
    num2 += 1
    lock.release()
    return num2

def run3():
    lock.acquire()
    res1 = run1()
    print("--------between run1 and run2-------")
    res2 = run2()
    lock.release()
    print("函数run1--->",res1,"函数run2--->",res2)

if __name__ == ‘__main__‘:
    num1 = 0
    num2 = 0
    lock = threading.RLock()
    for i in range(5):
        t = threading.Thread(target=run3)
        t.start()

while threading.active_count() != 1:
    print("剩余的线程数;[%s]" %threading.active_count())
else:
    print("all thread is down")
    print(num1,num2)

  

时间: 2024-10-10 10:17:26

python之递归锁【Rlock】的相关文章

python基础 多线程threading join 守护线程setDeamon 递归锁Rlock

开篇大概介绍多线程与多进程区别,详细的理论区别自己可以在其它博客搜一下,这里不再赘述 同一进程下的多个线程共享内存数据,多个线程之间没有主次关系,相互之间可以操作:cpu执行的都是线程,默认程序会开一个主线程:进程是程序以及和程序相关资源的集合:某些场景下我们可以使用多线程来达到提高程序执行效率的目的,下面就多线程的一些基础知识做简要说明 简单的多线程 1 import threading, time 2 3 def test1(x): 4 time.sleep(5) 5 print(x**x)

线程同步锁、死锁、递归锁、信号量、GIL

目录 线程同步锁.死锁.递归锁.信号量.GIL 一.同步锁 二.死锁 三.递归锁(Rlock) 四.信号量(Semphare) 五.GIL(全局解释器锁) io密集型 计算密集型 线程同步锁.死锁.递归锁.信号量.GIL 一.同步锁 所有线程同一时间读写同一个数据,有的线程已经对数据进行修改了,造成有的线程拿到的数据时旧的数据,而不是修改后的数据,造成结果不正确,于是引入了同步锁解决问题, 同步锁的原理是同一时间只能有一个线程读写数据. 锁通常被用来实现对共享资源的同步访问.从threading

并发编程---死锁||递归锁---信号量---Event事件---定时器

死锁 互斥锁:Lock(),互斥锁只能acquire一次 递归锁:  RLock(),可以连续acquire多次,每acquire一次计数器+1,只有计数为0时,才能被抢到acquire # 死锁 from threading import Thread,Lock import time mutexA = Lock() mutexB = Lock() class MyThread(Thread): def run(self): self.f1() self.f2() def f1(self):

5.1.17 死锁与死锁的解决(递归锁)

1. 排斥锁可能会造成死锁,先看看死锁的现象 from threading import Thread,Lock import time mutexA=Lock() mutexB=Lock() class MyThread(Thread): def run(self): self.f1() self.f2() def f1(self): mutexA.acquire() print('%s 拿到了A锁' %self.name) mutexB.acquire() print('%s 拿到了B锁'

python开发线程:死锁和递归锁&信号量&定时器&线程queue&事件evevt

一 死锁现象与递归锁 进程也有死锁与递归锁,在进程那里忘记说了,放到这里一切说了额 所谓死锁: 是指两个或两个以上的进程或线程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去.此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程,如下就是死锁 from threading import Thread,Lock import time mutexA=Lock() mutexB=Lock() class MyThread(Thread):

Python进阶(3)_进程与线程中的lock(互斥锁、递归锁、信号量)

1.同步锁 (Lock) 当各个线程需要访问一个公共资源时,会出现数据紊乱 例如: 1 import threading,time 2 def sub(): 3 global num #对全局变量进行操作 4 5 temp=num 6 time.sleep(0.001) #模拟线程执行中出现I/o延迟等 7 num=temp-1 #所有线程对全局变量进行减一 8 9 time.sleep(1) 10 11 num=100 12 l=[] 13 14 for i in range(100): 15

python并发编程之多线程2------------死锁与递归锁,信号量等

一.死锁现象与递归锁 进程也是有死锁的 所谓死锁: 是指两个或两个以上的进程或线程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用, 它们都将无法推进下去.此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程, 如下就是死锁 1 死锁------------------- 2 from threading import Thread,Lock,RLock 3 import time 4 mutexA = Lock() 5 mutexB = Lock() 6

11.python并发入门(part4 死锁与递归锁)

一.关于死锁. 死锁,就是当多个进程或者线程在执行的过程中,因争夺共享资源而造成的一种互相等待的现象,一旦产生了死锁,不加人工处理,程序会一直等待下去,这也被称为死锁进程. 下面是一个产生"死锁"现象的例子: import threading import time lock_a = threading.Lock() lock_b = threading.Lock() class test_thread(threading.Thread): def __init__(self): su

python:线程,多线程锁,多线程递归锁

#!usr/bin/env python# -*- coding:utf-8 -*- __author__ = "Samson" import threading,timedef run(n): print("task", n) time.sleep(2) print("current thread:",threading.current_thread())#当前线程 t_obj = []#存线程实例start_time = time.time(