标签：相同 super 解释 range 1.5 info daemon [] 效率
什么是线程
进程:资源分配单位
线程:cpu执行单位(实体),每一个py文件中就是一个进程,一个进程中至少有一个线程
线程的两种创建方式:
一
from multiprocessing import Process
def f1(n):
print(n,‘号线程‘)
if __name__ == ‘__main__‘:
t1 = Thread(target=f1,args=(1,))
t1.start()
print(‘主线程‘)
二
from threading import Thread
class MyThread(Thread):
def __init__(self,name):
super().__init__()
self.name = name
def run(self):
print(‘hello:‘ + self.name)
if __name__ == ‘__main__‘:
t = MyThread(‘haha‘)
t.start()
print(‘主线程结束‘)
线程的创建和销毁,相对于进程来说开销特别小
线程之间资源共享,共享的是同一个进程中的资源, 资源共享就涉及到数据安全问题,加锁来解决
线程锁
From threading import Thread,Lock
def f1:
Loc.acquire()
代码
Loc.release()
main
Loc = Lock()
T = thread(target=f1,args=(loc,)
from multiprocessing import Queue
import queue
import time
from threading import Lock,Thread
num = 100
def f1(loc):
loc.acquire()
global num
tmp = num
tmp -= 1
time.sleep(0.001)
num = tmp
loc.release()
if __name__ == ‘__main__‘:
t_loc = Lock()
t_list = []
for i in range(10):
t = Thread(target=f1,args=(t_loc,))
t.start()
t_list.append(t)
[tt.join() for tt in t_list]
print(‘主线的num‘,num)
锁:牺牲了效率,保证了数据安
死锁现象(天长地久,永不分离):
出现在锁嵌套的时候,双方互相抢对方已经拿到的锁,导致双方互相等待,这就是死锁现象
import time
from threading import Thread,Lock,RLock
def f1(locA,locB):
locA.acquire()
print(‘f1>>1号抢到了A锁‘)
time.sleep(1)
locB.acquire()
print(‘f1>>1号抢到了B锁‘)
locB.release()
locA.release()
def f2(locA,locB):
locB.acquire()
print(‘f2>>2号抢到了B锁‘)
locA.acquire()
time.sleep(1)
print(‘f2>>2号抢到了A锁‘)
locA.release()
locB.release()
if __name__ == ‘__main__‘:
locA = Lock()
locB = Lock()
t1 = Thread(target=f1,args=(locA,locB))
t2 = Thread(target=f2,args=(locA,locB))
t1.start()
t2.start()
递归锁:
解决死锁现象
Rlock 首先本身就是个互斥锁,维护了一个计数器,每次acquire就+1,release就-1,当计数器为0的时候,大家才能抢这个锁
import time
from threading import Thread, Lock, RLock
def f1(locA, locB):
locA.acquire()
print(‘f1>>1号抢到了A锁‘)
time.sleep(1)
locB.acquire()
print(‘f1>>1号抢到了B锁‘)
locB.release()
locA.release()
def f2(locA, locB):
locB.acquire()
print(‘f2>>2号抢到了B锁‘)
locA.acquire()
time.sleep(1)
print(‘f2>>2号抢到了A锁‘)
locA.release()
locB.release()
if __name__ == ‘__main__‘:
locA = locB = RLock()
t1 = Thread(target=f1, args=(locA, locB))
t2 = Thread(target=f2, args=(locA, locB))
t1.start()
t2.start()
守护线程:
守护线程:等待所有非守护线程的结束才结束
守护进程:主进程代码运行结束,守护进程就随之结束
import time
from threading import Thread
from multiprocessing import Process
def f1():
time.sleep(2)
print(‘1号线程‘)
def f2():
time.sleep(3)
print(‘2号线程‘)
if __name__ == ‘__main__‘:
t1 = Thread(target=f1,)
t2 = Thread(target=f2,)
t2.daemon = True
t1.start()
t2.start()
print(‘主线程结束‘)
GIL锁 :
cpython解释器上的一把互斥锁,当线程需要进入cpu做运算时必须一个一个经过GIL锁
线程的事件,信号量 与进程的事件,信号量 用法相同.
python并发编程之线程(创建线程,锁(死锁现象,递归锁),GIL锁)
标签：相同 super 解释 range 1.5 info daemon [] 效率
原文地址：https://www.cnblogs.com/fu-1111/p/10267714.html
