线程_递归锁

#死锁:锁只能抢一次,释放后被其他人抢
from threading import Thread,Lock,current_thread
import time
class MyThread(Thread):
    def run(self):
        self.f1()
        self.f2()
    def f1(self):
        mutexA.acquire()
        print("%s 抢到A锁" %current_thread().getName())
        mutexB.acquire()
        print("%s 抢到B锁" %current_thread().getName())
        print("%s 释放B锁" %current_thread().getName())
        mutexB.release()
        print("%s 释放A锁" %current_thread().getName())
        mutexA.release()

    def f2(self):
        mutexB.acquire()
        print("%s 抢到B锁" %current_thread().getName())
        time.sleep(1)
        mutexA.acquire()
        print("%s 抢到A锁" %current_thread().getName())
        print("%s 释放A锁" %current_thread().getName())
        mutexA.release()
        print("%s 释放B锁" %current_thread().getName())
        mutexB.release()

if __name__=="__main__":
    mutexA=Lock()
    mutexB=Lock()
    for i in range(20):
        t=MyThread()
        t.start()
# ‘‘‘
# Thread-758 抢到A锁
# Thread-758 抢到B锁
# Thread-758 释放B锁
# Thread-758 释放A锁
# Thread-758 抢到B锁
# Thread-759 抢到A锁
# ‘‘‘
    
# 递归锁:锁可以抢多次,acquire一次,count加1,release一次,count减1,直到count=0,锁最终释放别其他人抢from threading import Thread,RLock,current_thread
import time
class MyThread(Thread):
    def run(self):
        self.f1()
        self.f2()
    def f1(self):
        mutex.acquire()
        print("%s 抢到锁" %current_thread().getName())
        mutex.acquire()
        print("%s 抢到锁" %current_thread().getName())
        print("%s 释放锁" %current_thread().getName())
        mutex.release()
        print("%s 释放锁" %current_thread().getName())
        mutex.release()

    def f2(self):
        mutex.acquire()
        print("%s 抢到锁" %current_thread().getName())
        time.sleep(1)
        mutex.acquire()
        print("%s 抢到锁" %current_thread().getName())
        print("%s 释放锁" %current_thread().getName())
        mutex.release()
        print("%s 释放锁" %current_thread().getName())
        mutex.release()

if __name__=="__main__":
    mutex=RLock()
    for i in range(20):
        t=MyThread()
        t.start()
‘‘‘
Thread-808 抢到锁
Thread-808 抢到锁
Thread-808 释放锁
Thread-808 释放锁
Thread-810 抢到锁
Thread-810 抢到锁
Thread-810 释放锁
Thread-810 释放锁

‘‘‘
#线程:信号量【锁】

from threading import Thread,current_thread,Semaphore
import time,random
sm=Semaphore(3)
def work():
    sm.acquire()
    print("target %s is running" %current_thread().getName())
    time.sleep(random.randint(1,3))
    sm.release()

if __name__=="__main__":
    for i in range(10):
        t=Thread(target=work)
        t.start()

原文地址:https://www.cnblogs.com/hapyygril/p/12590085.html

时间: 2024-10-08 10:34:35

线程_递归锁的相关文章

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

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

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开发线程:死锁和递归锁&信号量&定时器&线程queue&事件evevt

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

Lock锁_线程_线程域

using System;using System.Collections.Generic;using System.ComponentModel;using System.Data;using System.Drawing;using System.Linq;using System.Text;using System.Threading;using System.Threading.Tasks;using System.Windows.Forms; namespace Lock锁_线程_线程

递归锁+条件锁+互斥锁-04-多线程

1 // 2 // ViewController.m 3 // 05-递归锁(recursive)+条件锁(condition) 4 // 5 // Created by mac on 16/4/20. 6 // Copyright © 2016年 mac. All rights reserved. 7 // 8 /* 9 10 3). 互斥锁 11 NSLock *_lock; 12 13 3)NSLock :不能多次调用,会产生死锁 14 15 2016-04-20 16:06:44.600

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(

python全栈开发基础【第二十五篇】死锁,递归锁,信号量,Event事件,线程Queue

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

python-GIL、死锁递归锁及线程补充

一.GIL介绍 GIL全称 Global Interpreter Lock ,中文解释为全局解释器锁.它并不是Python的特性,而是在实现python的主流Cpython解释器时所引入的一个概念,CIL本质上就是一把互斥锁,将并发运行变成串行,以此来控制同一时间内共享数据只能被一个任务所修改,从而保证数据的安全性. 注:每次执行python程序,都会产生一个独立的进程,进程里除了能看到的若干线程,还有看不见的解释器开启的垃圾回收等解释器级别的线程. #1 所有数据都是共享的,这其中,代码作为一

10 并发编程-(线程)-GIL全局解释器锁&死锁与递归锁

一.GIL全局解释器锁 1.引子 在Cpython解释器中,同一个进程下开启的多线程,同一时刻只能有一个线程执行,无法利用多核优势 首先需要明确的一点是GIL并不是Python的特性,它是在实现Python解析器(CPython)时所引入的一个概念. 就好比C++是一套语言(语法)标准,但是可以用不同的编译器来编译成可执行代码.>有名的编译器例如GCC,INTEL C++,Visual C++等.Python也一样,同样一段代码可以通过CPython,PyPy,Psyco等不同的Python执行