作者 by Joab / 2022-04-14 / 暂无评论 / 271 个足迹
Thread实例对象的方法
# isAlive(): 返回线程是否活动的。
# getName(): 返回线程名。
# setName(): 设置线程名。
threading模块提供的一些方法:
# threading.currentThread(): 返回当前的线程变量。
# threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前,不包括启动前和终止后的线程。
# threading.activeCount(): 返回正在运行的线程数量,与len(threading.enumerate())有相同的结果。
# 开启线程的方式一
from threading import Thread
def task(s1):
print("线程开启了")
if __name__ == '__main__':
s1 = '线程开启了'
# args可迭代对象元组只有一个参数的情况需要加","
p = Thread(target=task, args=(s1,))
p.start()
# 开启线程的方式二,继承Thread类重新run方法
from threading import Thread
class Task2(Thread):
def __init__(self, name):
super().__init__()
self.name = name
def run(self):
# print(self.name)
print("牛逼")
if __name__ == '__main__':
t = Task2("Joab")
t.start()
import time
from threading import Thread
from multiprocessing import Process
import os
def work():
time.sleep(2)
print('hello')
if __name__ == '__main__':
# 在主进程下开启线程
start_t = time.time()
t = Thread(target=work)
t.start()
t.join()
print('主进程开启线程')
print(time.time() - start_t)
# 在主进程下开启子进程
start_t = time.time()
t = Process(target=work)
t.start()
t.join()
print('主进程开启进程')
print(time.time() - start_t)
# 输出
hello
主进程开启线程
2.021684408187866
hello
主进程开启进程
2.234938383102417
# 结论
开启线程速度更快,资源占用小
无论是进程还是线程,都遵循:守护xxx会等待主xxx运行完毕后被销毁
from threading import Thread
import time
def sayhi(name):
print('%s say hello' % name)
time.sleep(2)
if __name__ == '__main__':
t = Thread(target=sayhi, args=('Joab',))
# 声明是守护线程,而不是t.Daemon = True
t.setDaemon(True) # 必须在t.start()之前设置
t.start()
# 开启的线程是否存活
print(t.is_alive())
# 输出,因为打印改结果时候主进程未关闭,所以守护线程存活是True
Joab say hello
True
三个需要注意的点:
#1.线程抢的是GIL锁,GIL锁相当于执行权限,拿到执行权限后才能拿到互斥锁Lock,其他线程也可以抢到GIL,但如果发现Lock仍然没有被释放则阻塞,即便是拿到执行权限GIL也要立刻交出来
#2.join是等待所有,即整体串行,而锁只是锁住修改共享数据的部分,即部分串行,要想保证数据安全的根本原理在于让并发变成串行,join与互斥锁都可以实现,毫无疑问,互斥锁的部分串行效率要更高
#3. 一定要看本小节最后的GIL与互斥锁的经典分析
from threading import Thread, Lock
import os, time
def work():
global n
# 公共数据的操作加锁
lock.acquire()
temp = n
time.sleep(0.1)
n = temp - 1
lock.release()
if __name__ == '__main__':
lock = Lock()
n = 100
l = []
for i in range(100):
p = Thread(target=work)
l.append(p)
p.start()
for p in l:
p.join()
print(n) # 结果肯定为0,由原来的并发执行变成串行,牺牲了执行效率保证了数据安全
所谓死锁: 是指两个或两个以上的进程或线程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程,如下就是死锁
from threading import Thread, Lock
import time
mutexA = Lock()
mutexB = Lock()
class MyThread(Thread):
def run(self):
self.func1()
self.func2()
def func1(self):
mutexA.acquire()
print('%s 拿到A锁' % self.name)
mutexB.acquire()
print('%s 拿到B锁' % self.name)
mutexB.release()
mutexA.release()
def func2(self):
mutexB.acquire()
print('%s 拿到B锁' % self.name)
time.sleep(2)
mutexA.acquire()
print('%s 拿到A锁' % self.name)
mutexA.release()
mutexB.release()
if __name__ == '__main__':
for i in range(10):
t = MyThread()
t.start()
解决方法,递归锁,在Python中为了支持在同一线程中多次请求同一资源,python提供了可重入锁RLock。
这个RLock内部维护着一个Lock和一个counter变量,counter记录了acquire的次数,从而使得资源可以被多次require。直到一个线程所有的acquire都被release,其他的线程才能获得资源。上面的例子如果使用RLock代替Lock,则不会发生死锁:
#一个线程拿到锁,counter加1,该线程内又碰到加锁的情况,则counter继续加1,这期间所有其他线程都只能等待,等待该线程释放所有锁,即counter递减到0为止
mutexA=mutexB=threading.RLock()
独特见解