python-并发编程

1 操作系统简单介绍
1.1 多道技术
操作系统实现
空间复用: 多个程序同时在运行
时间复用: 遇到io自动切换,把其他程序的io阻塞时间充分利用

2 进程
并发:伪并行,遇到io自动切换,保存状态
并行:多个cpu执行多个任务
2.1 进程
正在运行的程序,系统的最小资源单位
2.2 进程的三状态
就绪 运行 阻塞
2.3 同步\异步 阻塞\非阻塞
同步\异步 : 任务提交的2种方式
阻塞\非阻塞 : 任务的执行状态

3 进程的2种创建方法
函数
from multiprocessing import Process
def f1(n):
print('xx')
for i in range(10):
p = Process(target=f1,args=(1,))
p.start()
类
class MyProcess(Process):
def run(self):
print('xx')
p = MyProcess()
p.start()

4 进程之间空间隔离的

5 join 阻塞
p.join() 用列表添加最后执行
等待子进程结束,主进程才结束

6 守护进程
主进程运行结束,守护进程随着结束
在start() 之前加 p.daemon = True

7 锁\互斥锁\同步锁
并发执行任务,多个任务同时操作共享数据的时候,会造成数据混乱的问题
操作共享数据的代码的部分要加锁
lock = Lock()
with lock:
pass

8 死锁现象
进程和线程是一样的
锁嵌套引起的死锁现象,双方互相抢对方已经拿到的锁,导致双方互相等待
递归锁解决死锁现象

9 GIL锁 全局解释器锁
加在Cpython解释器上的一吧锁,同一时间是能解释一个线程,导致多线程应用不了多核

10 进程队列
from multiprocessing import Queue 先进先出
put get

---------------------------------------------------------------------------------------------

11 线程的2种创建方法
函数
from threading import Thread
def f1(n):
print('xx')
for i in range(10):
p = Thread(target=f1,args=(1,))
p.start()
类
class MyThread(Thread):
def run(self):
print('xx')
p = MyThread()
p.start()

12 守护线程
等待主线程和其他子线程结束,守护线程结束 t.daemon = True

13 join
t.join() 父线程等待子线程运行结束才继续执行

14 线程数据共享

15 线程锁\互斥锁\GIL

16 线程队列
import queue
先进先出
q = queue.Queue()
先进后出
q = queue.LifoQueue()
优先级队列
q = queue.PriorityQueue()
q.put((1,'xx')) # 数字表示优先级

17 线程池
form concurrent.futures import ThreadPoolExecutor

def f1(n):
print(n)
return n+1
def call_back(m):
print(.result())
pool = ThreadPoolExecutor(3)
res = pool.submit(f1,'abc') 执行函数
print(res.result()) 阻塞 拿到返回值
pool.shutdown() 关闭线程池
res = pool.submit(f1,1).add_done_callback(call_back)
回调函数,将前面提交的f1任务的返回结果,作为参数给了call_back函数,需要result来

优势: 不需要重复的创建和销毁,想拿就拿