# 整理并发中涉及的模块
一. 进程
1. multiprocessing 多元化进程模块
① from multiprocessing import Process # 从multiprocessing中 导入Process进程类
语法:
def 函数名(args):
pass
if __name__ = "__main__":
p = Process(target=函数名, args=参数) # 进程实例化, 参数是可迭代对象, 一般用元组 (args,)
方法:
p.start() # 不是开始执行, 而是, 通知cpu可以调用我了
p.terminate() # 关闭子进程(有一点延迟,之后才关闭. 异步非阻塞)
p.is_alive() # 判断进程是否正在执行
p.join() # 阻塞,直到p对应的进程结束之后才结束阻塞
p.daemon = True # 设置守护进程
属性:
p.name # 打印效果: Process-1 获取该进程的进程号
p.pid # 打印效果: 3172 获取该进程在电脑中的唯一pid码
os模块中相关方法:
os.getpid() # 获取进程在电脑中的唯一pid码
os.getppid() # 获取进程的父进程在电脑中的唯一pid码
面向对象的方式实现多进程:
from multiprocessing import Process
class MyProcess(Process): # 继承Process类
def __init__(self, args) # 可以传参数
self.args = args
def run(self): # 必须实现run方法, 希望在子进程中执行的代码就放在run方法中
pass
② from multiprocessing import Lock # 进程中的锁 , 保证数据安全
语法:
lock = Lock() # 锁的实例化
方法:
lock.acquire() # 获取执行代码的权限
lock.release() # 释放权限
with Lock: # with上下文管理, 在pass之前执行acquire, 之后执行release
pass
③ from multiprocessing import Queue # 进程队列, 能完成进程之间的通信
语法:
q = Queue() # 队列实例化
方法:
q.put() # 向队列中放数据
q.get() # 从队列中取数据
④ from multiprocessing import Manager # 实现进程间的数据共享
语法:
m = Manager() # 实例化
方法:
dic = m.dict({'key':'value'}) # 构建让能让进程共享的字典
二. 线程
1. threading 线程模块
① from threading import Thread # 导入线程类
语法:
def 函数名(args):
pass
t = Thread(target=函数名, args=参数) # 进程实例化, 参数只能是元组(args,)
方法:
t.start() # 不是开始执行, 而是, 通知cpu可以调用我了
t.join() # 阻塞,直到t对应的线程结束之后才结束阻塞
t.daemon = True # 设置守护线程 等同于 t.setDaemon(True)
② from threading import currentThread # currentThread 提供了 .name 和 .ident 属性
语法:
t2 = currentThread() # 实例化
属性:
t2.name # 可以查看线程的名(编号)
t2.ident # 可以查看线程id
③ from threading import active_count # 返回当前正在工作的线程个数
语法:
print(active_count())
④ from threading import enumerate # 返回一个存储着所有正在执行的线程对象列表
语法:
print(enumerate()) # active_count() = len(enumerate())
⑤ from threading import Thread # 线程中的锁 , 保证数据安全
语法:
lock = Lock() # 锁的实例化
方法:
lock.acquire() # 获取执行代码的权限
lock.release() # 释放权限
with Lock: # with上下文管理, 在pass之前执行acquire, 之后执行release
pass
三. 进程池/线程池
1. concurrent.futures 池模块 # 池中放的是要执行任务的进程/线程数量,即:将要(futures)并发(concurrent)的进程/线程数量
① from concurrent.futures import ProcessPoolExecutor # 导入进程池
语法:
def func(i):
pass
def call_back():
pass
if __name__ == '__main__':
p = ProcessPoolExecutor(num) # 实例化, num为要创建的进程数量
方法:
# ret_l = []
for i in range(100):
ret = p.submit(func,i) # submit向池中提交任务,
ret.add_done_callback() # 回调函数, 拿到返回值后, 立即调用
ret_l.append(ret)
for r in ret_l: # 返回值 ret 为futures对象, 要用result()取值
print(r.result()) # result 为 阻塞方法
# ret = p.map(make, range(100)) # map() 等同于for循环 + submit
for i in ret: # ret是一个可迭代对象,迭代器(惰性运算),可以直接通过for循环从ret中获取返回值
print(i)
# p.shutdown() # map()和submit() 都要写在shutdown()之前
# 阻塞 直到池中的任务都完成为止
② from concurrent.futures import ThreadPoolExecutor # 导入线程池 , 应用与进程池 相同
四. 协程---第三方模块
1. greenlet 协程模块(手动切换协程)
① from greenlet import greenlet # 导入模块
语法:
def func1():
pass
def func2():
pass
方法:
g1 = greenlet(func1)
g2 = greenlet(func2)
g1.switch() # greenlet模块需要手动设置切换,遇到switch就切换,切回来时继续向下执行代码
2. gevent 协程模块(升级版)
① import gevent # 此模块能够自动规避IO(阻塞)操作, 但不识别其他方式的IO(阻塞)操作
语法:
def eat(): # 协程函数
pass
def sleep():
pass'
方法:
g1 = gevent.spawn(eat) # 生产协程
g2 = gevent.spawn(sleep)
gevent.sleep() # 模块中带有的 time.sleep()功能
gevent.joinall([g1,g2]) # 阻塞到协程结束. 等同于for循环 + join()
② from gevent import monkey;monkey.patch_all() # 导入monkey,并打上后面那句话.此时,就能识别大部分的IO(阻塞)操作,从而进行协程切换