并发编程概念大总结--干货
进程
进程是计算机中最小的资源分配单位，进行中的一个程序就是一个进程。
进程需要操作系统来调度，每个程序运行起来的时候需要给分配一些内存,开启关闭切换时间开销大,进程之间数据隔离,进程也有数据不安全的问题 用Lock解决
进程的三状态图： 就绪 运行 阻塞
就绪-->操系统调度 -->运行-遇到io操作->阻塞-阻塞状态结束->就绪
-时间片到了->就绪
进程的调度算法：给所有的进程分配资源或者分配CPU使用权的一种方法。
- 短作业优先、先来先服务、多级反馈算法
- 多级反馈算法：
- 多个任务队列，优先级从高到低
- 新来的任务总是优先级最高
- 每个新任务几乎会立即获得一个时间片时间
- 执行完一个时间片之后就会降到下一级队列中
- 总是优先级高的任务都执行完才执行优先级低的队列
- 并且优先级越高时间片越短
进程开启和关闭
父进程 开启了子进程
父进程 负责给 子进程回收子进程结束之后的资源
from multiprocessing import Process
import os
def func():
print(os.getpid(), os.getppid()) # pid process 子进程id ppid 父进程id
if __name__ == '__main__': # 只会在主进程中执行的所有的代码,写在__main__下边
print('main:', os.getpid(), os.getppid())
p = Process(target=func) # target表示调用对象，即子进程要执行的任务
p = Process(target=func,args=('安文',))
# p = Process(target=func,kwargs={'name':'安文'}) 两种传参方式
p.start() #异步非阻塞 启动进程，并调用该子进程中的p.run()
注意：在windows中Process()必须放到# if __name__ == '__main__':下
由于Windows没有fork，多处理模块启动一个新的Python进程并导入调用模块。
如果在导入时调用Process（），那么这将启动无限继承的新进程（或直到机器耗尽资源）。
这是隐藏对Process（）内部调用的原，使用if __name__ == “__main __”，这个if语句中的语句将不会在导入时被调用。
开启进程的另一种方法：
- 面向对象的方法，通过继承和重写run方法完成启动子进程
from multiprocessing import Process
# class 类名(Process):
# def __init__(self,参数):
# self.属性名=参数
# super().__init__()
# def run(self):
# print("子进程要执行的代码")
# p=类名()
# p.start()
Process类的一些其他方法和属性：name pid ident daemon terminate() isalive()
p.name 给子进程起名字
is_alive()方法由线程调用，有返回值，如果线程还存活，返回true，如果线程消亡，返回false
terminate() #强制结束子进程 异步非阻塞
守护进程：
# 主进程会等待所有子进程结束，是为了回收子进程的资源
# 守护进程会等待主进程的代码执行结束之后再结束，而不是等待整个主进程结束
# 主进程的代码什么时候结束，守护进程就什么时候结束，和其他子进程的执行进度无关
主进程创建守护进程：
- 守护进程会在主进程代码执行结束后就终止
- 守护进程内无法再开启子进程，否则抛出异常
注意：进程之间是相互独立的，主进程代码运行结束，守护进程随即终止
在start一个进程之前设置daemon=True,守护进程会等待主进程的代码结束就立即结束
p = Process(target=son2)
p.daemon = True # 一定要在p.start()前设置,表示设置p是一个守护进程
p.start()
为什么守护进程只守护主进程的代码？而不是等主进程结束之后才结束
# 为了给守护进程回收资源
# 守护进程会等其他子进程结束吗？不会
一般情况下，多个进程执行顺序可能是：
- 主进程代码结束-->守护进程结束-->子进程结束-->主进程结束
- 子进程结束-->主进程代码结束 -->守护进程结束-->主进程结束
进程之间通信(IPC):
-
基于文件：同一台机器上的多个进程之间通信
Queue队列：基于socket的文件级别的通信来完成数据传递的， 队列：安全 管道：不安全
-
基于网络：同一台机器或者多台机器上的多进程之间的通信
第三方工具：(消息中间件):memcache/redis/rabbitmq/kafka
进程之间可以通过Manager类实现数据共享
共享数据不安全，需要自己加锁解决数据安全问题
生产者模型 消费者模型：
- 本质：让生产数据和消费数据的效率达到平衡并且最大化效率
消费者:通常取到数据之后还要进行某些操作 消费者如何结束：None
生产者：通常在放数据之前需要先通过某些代码来获取数据
# 把原本获取数据处理数据的完整过程进行了解耦
# 把生产数据和消费数据分开，根据生产和消费的效率不同，
# 来规划生产者和消费者的个数，让程序的执行效率达到平衡
# 如果你写了一个程序所有的代码、和功能都放在一起
# 不分函数不分类也不分文件，就叫这个程序是紧耦合的程序
# 紧耦合程序：代码只写一次，不需要重构
# 松耦合的程序：需要重构，不断迭代 复用代码
# 拆分的很清楚的程序 叫做 松耦合的程序，松耦合程序好
from multiprocessing import Queue,Pipe
# 队列:ipc进程之间通信，队列数据安全，不需要自己加锁。队列做通信，信息之间传递，
# 基于socket实现的，pickle实现，锁实现，
# pipe管道：也像队列一样，可以放数据可以取数据，没有锁数据不安全，
# 基于socket、pickle 实现的。没有锁 数据不安全
锁----multiprocessing.Lock:
加锁可以保证多个进程修改同一块数据时，同一时间只能有一个任务可以进行修改，即串行修改，导致速度慢了，但保证了数据安全。
锁:保证数据安全，会降低程序的运行效率，数据安全
互斥锁，多进程中共享的数据需要加锁
# from multiprocessing import Lock #互斥锁，多进程中共享的数据需要加锁
# lock=Lock()
# lock.acquire()
# '''被锁的内容在这里写'''
# lock.release()
# with lock：
# ...
并行：
好，高效，多个cpu在自己的cpu上执行多个程序
并发：
一个cpu多个程序轮流执行，10个程序轮流使用一个cpu
多个程序同时执行，只要一个CPU,多个程序轮流在一个CPU上执行
宏观上：多个程序同时执行
微观上：多个程序轮流在一个CPU上执行，本质上是串行
同步异步阻塞非阻塞
同步：调用一个操作要等待结果
在做A件事的时候发起B事，必须等待B事件结束之后才能继续A事件
异步：更快，调用一个操作，不等待结果
在做A件事的时候发起B事，不需要等待B事件结束之后才能继续A事件
阻塞:如果CPU不工作 input accept recv sleep connect
非阻塞：如果CPU在工作
# 同步阻塞：调用一个函数需要等待这个函数的执行结果，并且在执行这个函数的过程中CPU不工作 num=input('>>>')
# 同步非阻塞：调用一个函数需要等待这个函数的执行结果，并且在执行这个函数的过程中CPU工作 ret=eval(1+2+3+4)
# 异步非阻塞:start() 调用一个函数不需要等待这个函数的执行结果，并且在执行这个函数的过程中CPU工作
# 异步阻塞:调用一个函数不需要等待这个函数的执行结果，并且在执行这个函数的过程中CPU不工作
# 10个异步的进程，获取这个进程的返回值，并且能做到哪一个进程结束，就先获取谁的返回值
# 同步阻塞
# 调用函数必须等待结果，cpu没工作，input sleep recv accept content get
# 同步非阻塞 *******
# 调用函数必须等待结果，cpu工作了，调用了一个高计算的函数 ，strip,eval,max,sorted同步非阻塞
# 异步阻塞
# 调用函数不需要立即获取结果，而是继续做其他的事情，在获取结果的时候不知道先获取谁的，但是总之要等
# 异步非阻塞 *******
# 调用函数不需要立即获取结果，也不需要等 start terminate
线程
线程是计算机中能被CPU调度的最小单位，线程是进程中的一个单位，不能脱离进程存在，线程必须存在进程内。cpu执行的是解释之后的线程中的代码，同一个进程中的多个线程可以同时被CPU执行。线程之间的数据是共享的，操作系统调度的最小单位，可以利用多核，操作系统调度，数据不安全，开启关闭切换时间开销非常小
全局解释器 GIL (global interpreter lock)：
- 在cpython解释器下有个GIL锁（全局解释器锁）;全局解释器锁的出现主要是为了完成GC的回收机制，对不同线程的引用计数的变化记录的更加精准； 导致了同一个进程只能有一个线程真正被CPU执行,导致了同一个进程中的多个线程不能利用多核（不能并行）
- 节省的是IO操作的时间，而不是CPU计算的时间，因为CPU的计算速度非常快，大部分情况下，我们没办法把一条进程中所有的io操作都规避掉
GC:垃圾回收机制，就是一个线程
pypy解释器 gc不能用多核
jpython解释器 gc能利用多核
开启线程:
# import time
# from threading import Thread
# def func(i):
# print("start%s"%i)
# time.sleep(1)
# print("end%s"%i)
# for i in range(10):
# Thread(target=func,args=(i,)).start()
# 面向对象方式起线程
# from threading import Thread
# class MyThread(Thread):
# def __init__(self,a,b):
# self.a=a
# self.b=b
# super().__init__()
# def run(self):
# print(self.ident)
# t=MyThread(1,2)
# t.start() #开启线程 才在线程中执行run方法
# print(t.ident)
# 线程是不能从外部关闭的 没有terminate
# 所有的子线程只能是自己执行完代码之后就关闭
# current_thread() 当前线程的对象,current_thread().itent()线程的id
# enumerate() 列表 存储了所有活着的线程对象,包括主线程和子线程
# active_count() 数字 存储了所有活着的线程个数
主线程会等子线程结束之后才结束，子线程不结束，主线程就不结束
;因为主线程结束进程就会结束
守护线程 : 守护线程随着主线程的结束而结束;
守护线程会在主线程的代码结束之后继续守护其他子线程
# 守护进程 会随着主进程的代码结束而结束，
# 如果主进程代码结束之后还有其他子进程在运行，守护进程不守护
# 守护线程 会随着主线程的结束而结束
# 如果主线程代码结束之后还有其他子线程在运行，守护线程也守护
# 守护进程和守护线程的结束原理不同
# 守护进程需要主进程来回收、守护线程是随着进程的结束才结束；所有的线程都会随着进程的结束而被回收的
# 其他子线程-->主线程结束-->主进程结束-->整个进程中所有的资源都被回收-->守护线程也会被回收
线程之间数据不安全
# += -= *= /= while if 数据不安全 +和赋值是分开的两个操作
# append pop strip数据安全
# 列表中的方法或者字典中的方法去操作全局变量的时候 数据安全
线程锁：
单例模式加锁 天生线程安全
import time
class A:
from threading import Lock
__instance=None
lock=Lock()
def __new__(cls, *args, **kwargs):
with cls.lock:
if not cls.__instance:
time.sleep(0.000001)
cls.__instance=super().__new__(cls)
return cls.__instance
def func():
a=A()
print(a)
from threading import Thread
for i in range(10):
Thread(target=func).start()
互斥锁和递归锁的区别：
- 递归锁 ：(RLock)效率低，但是解决死锁现象有奇效 万能钥匙，临时解决一些死锁现象
- 递归锁：在同一进程中可以被acquire多次，但一次acquire必须对应一次release
- 互斥锁 ：效率高，能够处理多个线程之间数据安全，但是多把互斥锁交替的使用容易产生死锁现象
- 互斥锁：在同一个进程中不能被连续acquire多次，一次acquire对应一次release
死锁现象是怎么产生的？
多把（互斥锁/递归）锁并且在多个线程中交叉使用，（比如：两把锁，在第一把锁没有释放之前就获取第二把锁）
解决死锁现象：
- 出现了死锁现象，最快速的解决方案把所有的互斥锁都改成一把递归锁，程序的效率会降低
队列：queue；
线程队列特点：数据安全，一定是加锁了,先进先出
池
什么是池？
- 要在程序还没开始的时候，还没提交任务先创建几个线程或进程放在一个池子里
为什么要用池？
- 如果先开好线程或者进程，那么有任务之后就可以直接使用这个池中的数据了，节省时间
- 并且开好的线程或进程一直存在池中，可以被多个任务反复利用，这样极大的减少了开启和关闭、调度线程/进程的时间开销。
- 池中的线程/进程个数控制了操作系统需要调度的任务个数，控制池中的单位有利于提高操作系统的效率，减轻操作系统的负担
# multiprocessing 模块 仿照threading写的pool
# concurrent.futures模块，线程池和进程池都能够用相似的方式开启和使用
#ThreadPoolExecutor：线程池，提供异步调用
#ProcessPoolExecutor: 进程池，提供异步调用
线程池：（一般根据io的比例定制）
import time
import random
from threading import current_thread
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
def func(a,b):
print(current_thread().ident,'start',a,b) #接收参数
time.sleep(random.randint(1,4))
print(current_thread().ident,'end')
tp=ThreadPoolExecutor(4)
for i in range(20):
tp.submit(func,i,i+1) #按位置传参数
tp.submit(func, a=i, b=i + 1) #关键字传参数
进程池：
进程池（高计算场景，没有io（没有文件操作、没有数据库操作、没有网络操作
、没有input））
import os
import time
import random
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
def func(a,b):
print(os.getpid(),'start',a,b) #接收参数
time.sleep(random.randint(1,4))
print(os.getpid(),'end')
if __name__ == '__main__':
pp=ProcessPoolExecutor(4)
for i in range(20):
pp.submit(func,i,i+1) #按位置传参数
pp.submit(func, a=i, b=i + 1) #关键字传参数
回调函数:效率最高
import time
import random
from threading import current_thread
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
def func(a,b):
print(current_thread().ident,'start',a,b) #接收参数
time.sleep(random.randint(1,4))
print(current_thread().ident,'end',a)
return （a,a*b)
def print_func(ret): #异步阻塞
print(ret.result())
if __name__ == '__main__':
tp=ThreadPoolExecutor(4)
for i in range(20): #提交任务是异步非阻塞
ret=tp.submit(func,i,i+1) #按位置传参数
ret.add_done_callback(print_func) #异步阻塞
# 回调函数 给ret对象绑定一个回调函数，等待ret对应的任务有了结果之后立即调用print_func这个函数
# 就可以对结果立即进行处理，而不用按照顺序接收处理结果
协程
协程：是操作系统不可见的
- 协程本质就是一条线程，多个任务在一条线程上来回切换；
- 利用协程这个概念实现的内容：规避io操作，达到将一条线程中的io操作降到最低的目的
# 切换并规避io操作的模块：
# gevent:利用了greenlet底层模块完成的切换+自动规避io的功能
# asyncio:利用了yield底层语法完成的切换+自动规避io的功能
# tornado异步的web框架
# yield from:为了更好的实现协程
# send为了更好的实现协程
# asyncio 模块 基于Python原生的协程的概念正式被成立
# 特殊的在Python中提供协程功能的关键字：aysnc await
用户级别的协程还有什么好处：
- 减轻操作系统的负担
- 一条线程如果开了多个协程，那么给操作系统的印象是线程很忙，
- 这样能争取一些时间片时间来被cpu执行，程序的效率就提高了
协程：
import gevent
def func():
print('start func')
gevent.sleep(1)
print('end func')
g=gevent.spawn(func)
g1=gevent.spawn(func)
gevent.joinall([g,g1])
asyncio：
import asyncio
async def func(name): #async协程函数
print("start",name)
#await 关键字必须写在async函数里
await asyncio.sleep(1) #await后面可能会生成阻塞的方法
print('end')
loop=asyncio.get_event_loop() #事件循环
loop.run_until_complete(asyncio.wait([func('wudi'),func('anwen')]))
进程、线程和协程
# 进程：进程之间数据隔离，数据不安全，由操作系统（级别）切换，开销非常大，能利用多核
# 线程：线程之间数据共享，数据不安全，由操作系统（级别）切换，开销小,不能利用多核
# 协程：协程之间数据共享，数据安全 ，用户级别，开销更小，不能利用多核，协程的所有切换都基于用户，那么只有在用户级别
# 能够感知到的io操作才会用协程模块来切换来规避(socket,请求网页的)
asyncio
async def func(name): #async协程函数
print("start",name)
#await 关键字必须写在async函数里
await asyncio.sleep(1) #await后面可能会生成阻塞的方法
print('end')
loop=asyncio.get_event_loop() #事件循环
loop.run_until_complete(asyncio.wait([func('wudi'),func('anwen')]))
进程、线程和协程
# 进程：进程之间数据隔离，数据不安全，由操作系统（级别）切换，开销非常大，能利用多核
# 线程：线程之间数据共享，数据不安全，由操作系统（级别）切换，开销小,不能利用多核
# 协程：协程之间数据共享，数据安全 ，用户级别，开销更小，不能利用多核，协程的所有切换都基于用户，那么只有在用户级别
# 能够感知到的io操作才会用协程模块来切换来规避(socket,请求网页的)
