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()for i in range(50):    t = threading.Thread(target=run,args=("t%s" %i,))    #t.setDaemon(True)#把当前线程设置为守护线程,必须在t.start()之前设置,作用为主线程将不会等待该子线程结束    t.start()    t_obj.append(t)print("total thread:",threading.active_count())#总线程数for t in t_obj:    t.join()#等待线程执行完print("%s" %(abs(start_time-time.time())))

多线程锁
#!usr/bin/env python# -*- coding:utf-8 -*-

__author__ = "Samson"

import threading,timedef run(n):    lock.acquire()#锁上    global num    num += 1    #time.sleep(1)#会变为单线程    lock.release()#解锁lock = threading.Lock()#创建锁num = 0t_obj = []#存线程实例for i in range(50):    t = threading.Thread(target=run,args=("t%s" %i,))    t.start()    t_obj.append(t)for t in t_obj:    t.join()print("%s" %num)
多线程递归锁
#!usr/bin/env python# -*- coding:utf-8 -*-

__author__ = "Samson"

import threading,timedef run():    lock.acquire()#锁上    res = run1()    res2 = run2()    lock.release()#解锁def run1():    lock.acquire()#锁上    global num    num += 1    lock.release()#解锁def run2():    lock.acquire()#锁上    global num    num += 1    lock.release()#解锁lock = threading.RLock()#创建递归锁num = 0for i in range(10):    t = threading.Thread(target=run)    t.start()print("Now:",threading.active_count())while threading.active_count() != 1:    print(threading.active_count())else:    print("%s" %num)


原文地址:https://www.cnblogs.com/cansun/p/8379709.html

时间: 2024-11-07 23:21:32

python:线程,多线程锁,多线程递归锁的相关文章

Python并发编程05/ 死锁/递归锁/信号量/GIL锁/进程池/线程池

目录 Python并发编程05/ 死锁/递归锁/信号量/GIL锁/进程池/线程池 1.昨日回顾 2.死锁现象与递归锁 2.1死锁现象 2.2递归锁 3.信号量 4.GIL全局解释器锁 4.1背景 4.2为什么加锁 5.GIL与Lock锁的区别 6.验证计算密集型IO密集型的效率 6.1 IO密集型 6.2 计算密集型 7.多线程实现socket通信 7.1服务端 7.2客户端 8.进程池,线程池 Python并发编程05/ 死锁/递归锁/信号量/GIL锁/进程池/线程池 1.昨日回顾 #生产者消

并发&并行 同步&异步 GIL 任务 同步锁 死锁 递归锁

# 并发&并行 同步&异步 GIL 任务 同步锁 死锁 递归锁 # 并发:是指系统具有处理多个任务(动作)的能力 # 并行:是指系统具有 同时 处理多个任务(动作)的能力 # 同步:当进程执行到一个IO(等待外部数据)的时候,需要等待外部数据接收完 # 异步:当进程执行到一个IO(等待外部数据)的时候,不需要等待外部数据接收完,还可以做其它的处理 # GIL: 全局解释器锁 在python中,无论你启多少个线程,你有多少个cpu,python在执行的时候在同一时刻只请允许一个线程运行 #

ReactiveSwift源码解析(十一) Atomic的代码实现以及其中的Defer延迟、Posix互斥锁、递归锁

本篇博客我们来聊一下ReactiveSwift中的原子性操作,在此内容上我们简单的聊一下Posix互斥锁以及递归锁的概念以及使用场景.然后再聊一下Atomic的代码实现.Atomic主要负责多线程下的原子操作,负责共享资源的同步一致性.而在Atomic中就是使用到了Posix互斥锁和递归锁.在聊上述内容之前,我们先来回顾一下Swift语言中延迟执行defer的使用方式,在之前Swift编程的相关博客中也涉及到了defer的使用方式.defer因为Atomic使用到了延迟操作,所以下方我们再做一个

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

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

有关多线程(同步锁,递归锁,同步对象,信号量)

上面一个随笔已经简单介绍了多线程,比如下面在举个简单的例子: 1 #!/usr/bin/env python 2 #-*-coding:utf-8 -*- 3 4 import threading 5 import time 6 7 def add(): 8 sum = 0 9 10 for i in range(1000000): 11 sum += i 12 13 print("sum: ",sum) 14 15 16 def mul(): 17 sum2 = 1 18 for i

多线程——GIL\信号量\递归锁

互斥锁 1.什么是GIL(global interpreter lock)? GIL是一个互斥锁:保证数据的安全(牺牲效率来获取数据的安全),阻止同一个进程内的多线=线程同时执行(不能并行但是能实现并发)2.为什么会有GIL? 由于cpython解释器的内存管理不是线程安全的(垃圾回收机制的存在) 同一进程想的多线程不能实现并行但是可以实现并发,不同进程下可以实现并行 问题:Python多线程是不是就没有用: 举个例子: 四个任务:计算密集任务,每个任务10s 单核情况下: 多线程好点,消耗资源

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种方式,守护进程,锁,死锁,递归锁,GIL锁,其他方式)

###############总结############ 线程创建的2种方式(重点) 进程:资源分配单位    线程:cpu执行单位(实体) 线程的创建和销毁的开销特别小 线程之间资源共享,是同一个进程中的资源共享,会涉及到安全问题,所以需要加锁解决 锁:牺牲了效率,保证了数据安全(重点) 死锁现象:出现在嵌套的时候,双方互相抢对方已经拿到的锁,导致双方互相等待(重点) 递归锁: 解决了死锁现象(重点) rlock 首先本身就是个互斥锁,维护了一个计数器,每次acquire+1,release

线程的创建 验证线程之间共享数据 守护线程 线程进程效率对比 锁 死锁 递归锁

线程(from threading import Thread):CPU调度的最小单位 线程的两种创建方式:方式一: 1 from threading import Thread 2 def f1(i): 3 print(i) 4 if __name__ == '__main__': 5 for i in range(10): 6 t = Thread(target=f1,args=(i,)) 7 t.start() 8 print('主线程') 方式二: 1 from threading im

并发编程8 线程的创建&验证线程之间数据共享&守护线程&线程进程效率对比&锁(死锁/递归锁)

1.线程理论以及线程的两种创建方法 2.线程之间是数据共享的与join方法 3.多线程和多进程的效率对比 4.数据共享的补充线程开启太快 5.线程锁 互斥锁 同步锁 6.死锁现象和递归锁 7.守护线程和守护进程的对比 8.补充 9.GIL锁&GIL锁与线程锁的区别 10.GIL锁补充 11.信号量 时间补充说明 原文地址:https://www.cnblogs.com/studybrother/p/10269278.html