开启掘金成长之旅！这是我参与「掘金日新计划 · 12 月更文挑战」的第11天，点击查看活动详情
锁
死锁：两个或者两个以上的线程或者进程在执行的过程中 ， 因为资源竞争出现相互等待的情况
递归锁：这个锁可以加多次锁
from threading import Thread , RLock
g = 0
def func():
l.acquire()
t.acquire()
for i in range(100):
global g
g += 1
print(g)
t.release()
l.release()
def fun():
l.acquire()
for i in range(100):
global g
g -= 1
print(g)
l.release()
if __name__ == '__main__':
# 递归锁在内部会有一个变量，这个变量就会记录这个锁被创建多少次
t = l = RLock()
one = Thread(target=func)
two = Thread(target=fun)
one.start()
two.start()
定时器
是指定在第n秒之后开始执行任务
from threading import Timer
import time
def func():
print('线程执行之后的时间')
print(time.strftime("%Y-%m-%d %H:%M:%S"))
if __name__ == '__main__':
print('子线程启动前的时间')
print(time.strftime("%Y-%m-%d %H:%M:%S"))
t = Timer(3 , func)
t.start()
Event(了解)
Event就是一个标志 ， True跟False ， 提供一个wait函数阻塞当前线程任务 ， 阻塞的状态是从False变成True
False表示阻塞 ， 初始化Event对象默认是False
is_set() , 返回event状态
wait() 状态值为False为阻塞 ， 默认是False
set() 设置event状态值为True
clear() 恢复event的状态值为False
from threading import Event , Thread
import time
import random
# 红绿灯
def func_1():
while 1:
# 让任务设置为False
e.clear()
print('红灯亮起')
# 模拟红绿灯的等待时间
time.sleep(3)
# 将程序设置通行True
e.set()
print('绿灯亮起')
time.sleep(2)
# 设置行人
def func_2(name):
while 1:
# 判断是否可以通行，
if e.is_set():
print(f'{name}行人正在通行')
break
else:
print(f'{name}正在等待')
e.wait()
if __name__ == '__main__':
# 设置Event对象
e = Event()
# 设置启动红绿灯的线程
t = Thread(target=func_1)
t.start()
for i in range(10):
# 模拟行人到达路边的情况
time.sleep(random.randint(0,3))
p = Thread(target=func_2 , args=(f'Tom{i}号',))
p.start()
进程池
进程池：就是创建一定数量的进程 ， 当有任务进来执行的时候 ， 那么在池中的某一个进程进行处理任务 ， 当进程处理任务完毕 之后不关闭 ， 而是进入池中等到任务 。
进程池不会增加操作系统的调度难度 ， 还节省了开闭进程的时间 ， 在一定程度上能够事项并发效果
进程池的导入
# 进程池
from concurrent.futures import ProcessPoolExecutor
# 线程池
from concurrent.futures import ThreadPoolExecutor
from concurrent.futures import ProcessPoolExecutor
import time
# 设置进程池对象 ， 传入参数，就代表这个进程池的大小（有多少个进程）
# 没有参数，会默认开设当前计算机CPU个数的进程
pool_p = ProcessPoolExecutor(10)
def func(name):
print(f'{name}')
time.sleep(2)
if __name__ == '__main__':
for i in range(20):
pool_p.submit(func , i)
# submit(func , i)这个是有返回值的 ， 返回的是Future对象 ， 这个对象result方法，该方法是用来获取返回值的正在数据结果
from concurrent.futures import ProcessPoolExecutor
import time
# 设置进程池对象 ， 传入参数，就代表这个进程池的大小（有多少个进程）
# 没有参数，会默认开设当前计算机CPU个数的进程
pool_p = ProcessPoolExecutor(10)
def func(n):
# print(f'{n}')
time.sleep(2)
return n + 1
if __name__ == '__main__':
for i in range(20):
res = pool_p.submit(func , i)
print(res) # 获取到Future对象
print(res.result()) # 通过result方法获取到对象中每个任务返回的数据
# shutdown() 等待进程池中所有进程任务结束之后 ， 在执行主进程
from concurrent.futures import ProcessPoolExecutor
import time
# 设置进程池对象 ， 传入参数，就代表这个进程池的大小（有多少个进程）
# 没有参数，会默认开设当前计算机CPU个数的进程
pool_p = ProcessPoolExecutor(10)
def func(n):
# print(f'{n}')
time.sleep(2)
return n + 1
if __name__ == '__main__':
# 将所有任务的返回值添加到列表
ls = []
for i in range(20):
res = pool_p.submit(func , i)
ls.append(res)
print(res) # 获取到Future对象
# 等待进程池中所有进程任务结束之后 ， 在执行主进程
pool_p.shutdown()
for i in ls:
print(i.result()) # 通过result方法获取到对象中每个任务返回的数据
# 进程池/线程池有一个回调机制——add_done_callback()
from concurrent.futures import ProcessPoolExecutor
import time
# 设置进程池对象 ， 传入参数，就代表这个进程池的大小（有多少个进程）
# 没有参数，会默认开设当前计算机CPU个数的进程
pool_p = ProcessPoolExecutor(10)
def func(n):
# print(f'{n}')
time.sleep(2)
return n + 1
def f(fun):
print(f'获取到返回值结果{fun.result()}')
if __name__ == '__main__':
# 将所有任务的返回值添加到列表
ls = []
for i in range(20):
res = pool_p.submit(func , i)
# 回调机制不需要对任务进行参数传递 ， 参数会根据对象进行传入
res.add_done_callback(f)
进程是依靠电脑的操作系统进行调度；
线程是依靠电脑的CPU进行调度；
那么两者的调度顺序也是有操作系统或者CPU使用的调度决定的。
