并发编程
7.1.1、操作系统发展史
参考博客：https://www.cnblogs.com/Dominic-Ji/articles/10929381.html
7.1.2、多道技术
-
单核实现并发地效果
- 并发：开起来像是同时进行的可以称为并发。
- 并行：真正意义上的同时执行。
- 总结：并行肯定是并发；单核的计算机不能实现并行，但可以实现并发。
- 补充：我们假设单核就是一个核，干活的就是一个人，不要考虑CPU里面的内核数。
-
多道技术图解
-
多道技术重点
-
空间上的复用
- 多个程序公用一套操作系统
-
时间上的复用
-
只需要做时间长的哪一个，可以节省切换时间
-
保存状态，用户态和内核的切换
切换+保存状态
-
-
-
切换(CPU)分为两种情况：
- 当一个程序遇到IO操作时，操作系统会剥夺该程序的CPU执行效率权限。此时提高了CPU的利用率，并且也不影响程序的执行效率。
- 原因：在IO操作延迟的时候对CPU没有任何执行的空间，所以剥夺了也不会影响程序的运行。
- 当一个程序长时间占用CPU的时候，操作系统也会剥夺该程序的CPU执行权限，此时降低了程序的执行效率（原本时间+切换时间）
7.1.3、进程理论
-
必备知识点
-
程序和进程的区别
- 程序：是一对躺在硬盘上的代码，是‘死’的东西。
- 进程：是表示正在执行的过程，是‘活’的东西。
-
-
进程调度
-
先来先服务调度算法
- 对执行时间长的作业有利，对短作业无益。
- 因为一个长作业先到的话，后面的一个短作业就得等长作业执行完毕后才能把CPU空间给短作业。
-
短作业优先算法
- 如果一个长作业正在运行，来了一个短作业，这是会暂停长作业，把短作业运行完毕后再回到长作业继续执行。
-
时间片轮转法+多级反馈队列
- 不管长作业还是短作业都先放到一个队列中，统一执行一个规定的单位时间。
- 如果没在规定的时间执行完，会掉入第二优先级队列，再执行一个较长的单位时间。
- 此时来了一个作业会直接暂停第二梯队的工作
- 总结：活用了切换和保存状态，优化了不同大小作业的执行效率。
-
-
进程的三状态图
在了解其他概念之前，我们首先要了解进程的鸡哥状态。在程序运行的过程中，由于被操作系统的调度算法控制，程序会进入鸡哥状态：就绪、运行、阻塞。
-
就绪(Ready)状态
当程序已分配到除CPU以外的所有必要的资源，只要获得处理机便可立即执行，这时的进程状态就称为就绪状态。
-
执行/运行(Running)状态
当前进程已获得处理机，其程序正在处理机上执行，此时的进程状态就称为执行状态。
-
阻塞(Blocked)状态
正在执行的进程，由于等待某个事件发生而无法继续执行时，便放弃处理机而处于阻塞状态。引起进程阻塞的事件可有很多种，例如：等待IO完成、申请缓冲区不能满足、等待信号(信件)等。
-
-
两队重要概念
-
描述任务的提交方式
- 同步：任务提交之后，在原地等待任务的返回结果，等待的过程中不去做任何事，看上去就像是程序卡住了。
- 异步：任务提交后，不等待任务的返回结果，直接去做别的事情，任务的返回结果会有一个异步回掉机制自动处理。
- 通俗讲法：就像要把一份作业交给老师批改，小红交给老师了，站在原地等老师批改完，小红的行为叫做同步。而小李交给老师后就跑去完了，这种行为叫做异步。
-
描述程序的运行状态
- 阻塞(阻塞态)：是我们的程序基本都会遇到的状态，等待IO操作
- 非阻塞(就绪态、运行态)：是我们程序运行的理想状态，只在就绪态和云翔太之间切换，减少IO延迟
-
7.2、进程
7.2.1、开启进程的两种方式
-
方式一：
from multiprocessing import Process import time def task(name): print(f'{name} is running') time.sleep(3) print(f'{name} is over') if __name__ == '__main__': p = Process(target=task, args=('hz',)) p.start() print('^(*￣(oo)￣)^') -
方式二：类的继承
from multiprocessing import Process import time class MyProcess(Process): def run(self): print('hell 1') time.sleep(3) print('hello 2') if __name__ == '__main__': p = MyProcess() p.start() print('^(*￣(oo)￣)^') -
总结：创建进程就是在内存中申请一块内存空间将需要运行的代码丢进去 一个进程对应在内存中就是一块独立的内存空间 多个进程对应在内存中就是多块独立的内存空间 进程与进程之间数据默认情况下是无法直接交互,如果想交互可以借助于第三方工具、模块。
7.2.2、join方法
-
概念：join是让主进程等待子进程代码运行结束后，再运行。不影响其他子进程的执行（在进程开始后，加上进程对象.join()）
-
示例
from multiprocessing import Process import time def task(name): print(f'{name} is running') time.sleep(3) print(f'{name} is over') if __name__ == '__main__': p = Process(target=task, args=('hz',)) p.start() p.join() print('^(*￣(oo)￣)^')
7.2.3、进程间的数据相互隔离的
from multiprocessing import Process
import time
a = 100
def task(name):
print(f'{name} is running')
time.sleep(3)
global a
a = 101
print(a)
print(f'{name} is over')
if __name__ == '__main__':
p = Process(target=task, args=('hz',))
p.start()
print(a)
p.join()
print('^(*￣(oo)￣)^')
7.2.3、进程对象的其他方法
-
pid号：计算机通过给运行的进程分配pid号来管理计算机上的进程服务端。
-
windows查看方法：
- 进入cmd输入tasklist查看
- tasklist |findstr pid号 来查看具体的进程信息
-
mac电脑查看方式：
- 进入终端输入ps aux
- ps aux|grep pid号查看具体进程信息
from multiprocessing import Process, current_process current_process().pid # 查看当前进程的进程号 import os os.getpid() # 查看当前进程进程号 os.getppid() # 查看当前进程的父进程进程号 p.terminate() # 杀死当前进程 # 是告诉操作系统帮你去杀死当前进程 但是需要一定的时间 而代码的运行速度极快 time.sleep(0.1) print(p.is_alive()) # 判断当前进程是否存活
7.2.4、僵尸进程与孤儿进程（了解）
-
僵尸进程
- 僵尸：死了但没有死透。
- 当你开设了子进程之后，该进程死后不会立刻释放进程号，因为要让父进程能够查看到他开设的子进程的一些基本信息，占用的pid号、运行时间。
- 所有的进程都会步入僵尸进程。父进程不死并且无限制的创建子进程并且子进程也不会结束。
- 回收子进程：父进程等待子进程运行结束、父进程调用join方法。
-
孤儿进程
- 子进程存活，父进程意外死亡
- 操作系统会开设一个“儿童福利院”专门管理孤儿进程回收相关资源。
7.2.4、守护进程
-
概念：与主进程共生死
-
使用：通过进程对象的daemon方法把子进程设置成主进程的守护进程
from multiprocessing import Process import time def task(name): print('%s总管正在活着'% name) time.sleep(3) print('%s总管正在死亡' % name) if __name__ == '__main__': p = Process(target=task,args=('egon',)) # p = Process(target=task,kwargs={'name':'egon'}) p.daemon = True # 将进程p设置成守护进程 这一句一定要放在start方法上面才有效否则会直接报错 p.start() print('皇帝jason寿终正寝')
7.2.5、互斥锁
-
概念：多进程操作同一份数据时，该数据可能在同一时间被不同的进程修改，会出现数据错乱的现象
-
使用：针对这种情况，解决方式就是加锁处理，将并发改为串行，牺牲了效率，但保证了数据安全。
from multiprocessing import Process,Lock import time import json import random def search(): with open('a.txt','r',encoding='utf-8') as f: res = json.load(f) print('剩余：',res.get('count')) def buy(num): with open('a.txt', 'r', encoding='utf-8') as f: res = json.load(f) time.sleep(random.randint(1, 3)) if res.get('count') >0: print(f'{num}买到了一张') with open('a.txt','w',encoding='utf-8') as f : res['count'] = 0 json.dump(res,f) else: print('没票了') def all(num,mutex): search() mutex.acquire() buy(num) mutex.release() if __name__ == '__main__': mutex = Lock() for i in range(1,5): p = Process(target=all,args=(i,mutex,)) p.start() # p.join() print(f'{i}号顾客执行完毕') """ 注意： 1.锁不要轻易的使用，容易造成死锁现象(我们写代码一般不会用到，都是内部封装好的) 2.锁只在处理数据的部分加来保证数据安全(只在争抢数据的环节加锁处理即可) """
7.2.6、进程间通信
-
再理论上来讲，进程之间默认是无法通信的，但我们可以使用第三方模块、方法来实现继承间的通信。
管道:subprocess stdin stdout stderr 队列:管道+锁 队列:先进先出 堆栈:先进后出 """ from multiprocessing import Queue # 创建一个队列 q = Queue(5) # 括号内可以传数字 标示生成的队列最大可以同时存放的数据量 # 往队列中存数据 q.put(111) q.put(222) q.put(333) # print(q.full()) # 判断当前队列是否满了 # print(q.empty()) # 判断当前队列是否空了 q.put(444) q.put(555) # print(q.full()) # 判断当前队列是否满了 # q.put(666) # 当队列数据放满了之后 如果还有数据要放程序会阻塞 直到有位置让出来 不会报错 """ 存取数据 存是为了更好的取 千方百计的存、简单快捷的取 """ # 去队列中取数据 v1 = q.get() v2 = q.get() v3 = q.get() v4 = q.get() v5 = q.get() # print(q.empty()) # V6 = q.get_nowait() # 没有数据直接报错queue.Empty # v6 = q.get(timeout=3) # 没有数据之后原地等待三秒之后再报错 queue.Empty try: v6 = q.get(timeout=3) print(v6) except Exception as e: print('一滴都没有了!') # # v6 = q.get() # 队列中如果已经没有数据的话 get方法会原地阻塞 # print(v1, v2, v3, v4, v5, v6) """ q.full() q.empty() q.get_nowait() 在多进程的情况下是不精确 """
7.2.7、IPC机制
from multiprocessing import Queue, Process
"""
研究思路
1.主进程跟子进程借助于队列通信
2.子进程跟子进程借助于队列通信
"""
def producer(q):
q.put('我是23号技师 很高兴为您服务')
def consumer(q):
print(q.get())
if __name__ == '__main__':
q = Queue()
p = Process(target=producer,args=(q,))
p1 = Process(target=consumer,args=(q,))
p.start()
p1.start()
7.2.8、生产者消费者模型
-
生产者：生产/制造东西的
-
消费者：消费/处理东西的
-
该模型除了上述两个之外还需要一个媒介实现通信（进程之间默认是无法通信的）
-
通俗的解释：生活中的例子做包子的将包子做好后放在蒸笼(媒介)里面，买包子的取蒸笼里面拿 厨师做菜做完之后用盘子装着给你消费者端过去 生产者和消费者之间不是直接做交互的，而是借助于媒介做交互
-
生产者（做包子的）+消息队列（蒸笼）+消费者（吃包子的）
""" 生产者消费者模型：一个生产，一个消费，同时进行，但一定是生产者先生产出来了，消费者才能消费。 JoinableQueue： 每当你往该队列中存入数据的时候 内部会有一个计数器+1，没当你调用task_done的时候 计数器-1，q.join() 当计数器为0的时候 才往后运行 注意：此时使用Queue可能会出现生产者已经停止生产了，但消费者还是在消费，没有东西了，消费者会一直等下去，直到有东西来。 解决办法1：生产者生产完了，在队列中添加两个标识符，消费者再去判断。不过要使用join方法，当生产者工作完成后，再执行主进程的q.put()功能。 解决办法2：用JoinableQueue代替Queue，方法见上。此时生产者已经死了，但消费者还活着，问题还是没有解决 print(p1.is_alive()) --->False print(p2.is_alive()) --->False print(c1.is_alive()) --->True print(c2.is_alive()) --->True 这是就需要将消费者进程设置成守护进程 c1.daemon = True c2.daemon = True """ from multiprocessing import Process, Queue, JoinableQueue import time import random # 解决方法1 ''' # 生产者 def product(name, food, q): for i in range(1,6): data = '{}生产了{}{}。'.format(name,food,i) time.sleep(random.randint(1,4)) q.put(data) print(data) # 消费者 def consumer(name, q): while True: data = q.get() if data != None: time.sleep(random.randint(1, 4)) print('{}吃了{}'.format(name,data)) else: break if __name__ == '__main__': print('好戏开始了！') # 实例化一个队列 q = Queue() # 实例化两个生产者对象 p1 = Process(target=product,args=('egon','包子',q)) p2 = Process(target=product,args=('tank','油条',q)) # 实例化两个消费者对象 c1 = Process(target=consumer,args=('alex',q)) c2 = Process(target=consumer,args=('eric',q)) p1.start() p2.start() c1.start() c2.start() p1.join() p2.join() q.put(None) q.put(None) ''' # 解决方法2 ''' # 生产者 def product(name, food, q): for i in range(1,6): data = '{}生产了{}{}。'.format(name,food,i) time.sleep(random.randint(1,4)) q.put(data) print(data) # 消费者 def consumer(name, q): while True: data = q.get() if data: time.sleep(random.randint(1, 4)) print('{}吃了{}'.format(name, data)) q.task_done() if __name__ == '__main__': print('好戏开始了！') # 实例化一个队列 q = JoinableQueue() # 实例化两个生产者对象 p1 = Process(target=product,args=('egon','包子',q)) p2 = Process(target=product,args=('tank','油条',q)) # 实例化两个消费者对象 c1 = Process(target=consumer,args=('alex',q)) c2 = Process(target=consumer,args=('eric',q)) p1.start() p2.start() # 将消费者进程设置成守护进程 c1.daemon = True c2.daemon = True c1.start() c2.start() # p1.join() p2.join() # 若程序能走到这里，说明生产者已经死了 q.join() # 此时生产者已经死了，但消费者还活着，问题还是没有解决 # print(p1.is_alive()) - -->False # print(p2.is_alive()) - -->False # print(c1.is_alive()) - -->True # print(c2.is_alive()) - -->True '''
7.3、线程
7.3.1、线程理论
-
线程和进程的区别
- 进程：资源单位
- 线程：执行单位
-
形象总结：进程就是工厂的车间，线程就是车间内的流水线，进程为线程提供了运行的场所和加工的原材料，每个进程都带有一个或则多个线程。
-
抽象总结：进程是在内存中开辟一块新的内存空间，进程中有数据部分和线程部分，数据给线程提供处理的材料，被CPU执行的就是进程里线程。
-
PS：进程和线程都是虚拟单位，为了更方便取描述。
-
为何要有线程
- 一个进程内可以开设多个线程，在用同一进程内开设多个线程无需再次申请内存空间操作，这样节省了内存，也提高了效率。
7.3.2、开启线程的两种方式
from threading import Thread
import time
# 直接创建
def func():
time.sleep(1)
print('aaa')
if __name__ == '__main__':
t = Thread(target=func)
t.start()
print('xxx')
# 类继承创建
class MyThread(Thread):
def __init__(self,name):
super().__init__()
self.name = name
def run(self):
print('start....')
print(self.name)
if __name__ == '__main__':
t = MyThread('hz')
t.start()
print('🐖')
7.3.3、用进程和线程分别实现TCP
服务端
from multiprocessing import Process
from threading import Thread
import socket
def school(conn):
while True:
res = conn.recv(1024)
if len(res) == 0:break
res = res.decode('utf-8')
msg = f'{res}已被我校录取'
print(msg)
conn.send(msg.encode("utf-8"))
conn.close()
if __name__ == '__main__':#windows内的进程对象必须在mian里创建否则会报错
s = socket.socket()
s.bind(('127.0.0.1',8080))
s.listen(5)
while True:
conn,addr = s.accept()
# t = Thread(target=school,args=(conn,))
t = Process(target=school,args=(conn,))
t.start()
客户端
import socket
s = socket.socket()
s.connect(('127.0.0.1',8080))
while True:
msg = input("your name:")
s.send(msg.encode('utf-8'))
data = s.recv(1024)
print(data.decode('utf-8'))
7.3.4、线程对象实现join方法
from threading import Thread
import time
def text():
print(123)
time.sleep(2)
if __name__ == '__main__':
t = Thread(target=text)
t.start()
t.join()
print("🐖")
7.3.5、同一个进程下的线程数据时共享的
from threading import Thread
import time
money = 100
def task():
global money
money = 666
print(money)
if __name__ == '__main__':
t = Thread(target=task)
t.start()
t.join()
print(money)
7.3.6、线程对象及其他方法
from threading import Thread,active_count,current_thread
import time
a = 100
def text():
global a
a = 111
time.sleep(2)
print(a,)
if __name__ == '__main__':
t = Thread(target=text)
t1 = Thread(target=text)
t.start()
t1.start()
t.join()
print(active_count())# 统计当前活跃线程数，本身mian线程也是
print(current_thread().name) # 得到当前所在线程的名字
7.3.7、守护线程
-
核心：主线程运行结束之后不会立即结束，会等待其他非守护线程结束才会结束，因为主线程的结束意味着所在线程的进程的结束。
# from threading import Thread # import time # # # def task(name): # print('%s is running'%name) # time.sleep(1) # print('%s is over'%name) # # # if __name__ == '__main__': # t = Thread(target=task,args=('egon',)) # t.daemon = True # t.start() # print('主') # 稍微有一点迷惑性的例子 from threading import Thread import time def foo(): print(123) time.sleep(1) print('end123') def func(): print(456) time.sleep(3) print('end456') if __name__ == '__main__': t1 = Thread(target=foo) t2 = Thread(target=func) t1.daemon = True t1.start() t2.start() print('主.......')
7.3.8、线程互斥锁
from threading import Thread,Lock
import time
money = 100
mutex = Lock()
def task():
global money
mutex.acquire()
tmp = money
time.sleep(0.1)
money = tmp - 1
mutex.release()
if __name__ == '__main__':
t_list = []
for i in range(100):
t = Thread(target=task)
t.start()
t_list.append(t)
for t in t_list:
t.join()
print(money)
7.3.9、GIL全局解释器锁
"""
In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple
native threads from executing Python bytecodes at once. This lock is necessary mainly
because CPython’s memory management is not thread-safe. (However, since the GIL
exists, other features have grown to depend on the guarantees that it enforces.)
"""
"""
python解释器其实有多个版本
Cpython
Jpython
Pypypython
但是普遍使用的都是CPython解释器
在CPython解释器中GIL是一把互斥锁，用来阻止同一个进程下的多个线程的同时执行
同一个进程下的多个线程无法利用多核优势！！！
疑问:python的多线程是不是一点用都没有？？？无法利用多核优势
因为cpython中的内存管理不是线程安全的
内存管理(垃圾回收机制)
1.应用计数
2.标记清楚
3.分代回收
"""
"""
重点:
1.GIL不是python的特点而是CPython解释器的特点
2.GIL是保证解释器级别的数据的安全
3.GIL会导致同一个进程下的多个线程的无法同时执行即无法利用多核优势(******)
gil锁相当于线程锁，当一个进程内有多个线程出现，谁先执行取决于谁先拿到了gil锁，这个锁帮助这条线程打开了cup的执行权限，其他没有拿到的进程只能等待。
4.针对不同的数据还是需要加不同的锁处理
5.解释型语言的通病:同一个进程下多个线程无法利用多核优势
"""
7.3.10、GIL与普通互斥锁的区别
from threading import Thread,Lock
import time
mutex = Lock()
money = 100
def task():
global money
# with mutex:
# tmp = money
# time.sleep(0.1)
# money = tmp -1
mutex.acquire()
tmp = money
time.sleep(0.1) # 只要你进入IO了 GIL会自动释放
money = tmp - 1
mutex.release()
if __name__ == '__main__':
t_list = []
for i in range(100):
t = Thread(target=task)
t.start()
t_list.append(t)
for t in t_list:
t.join()
print(money)
"""
100线程同时创建完毕，这100个线程需要执行了，他们就会去抢GIL锁，抢到的那个可以开始执行代码，遇到了我们写的互斥锁，此时没有其他线程到了这一步就没有可以抢他的锁了，获取了money数据后，进入了io，此时这个线程就施放了GIL锁。在他io的这段时间，其他99个线程在争抢GIl锁，但是即使抢到了gil锁，他们也因为互斥锁把数据锁住了，导致他们无法获取数据，此时第一个抢到gil锁的线程结束io修改了数据施放了互斥所，也施放了gil锁，该线程结束。
"""
7.3.11、同一个进程下的多线程是无法利用多核优势的，是不是就没有用了
"""
多线程是否有用要看具体情况
单核:四个任务(IO密集型\计算密集型)
多核:四个任务(IO密集型\计算密集型)
"""
# 计算密集型 每个任务都需要10s
单核(不用考虑了)
多进程:额外的消耗资源
多线程:介绍开销
多核
多进程:总耗时 10+
多线程:总耗时 40+
# IO密集型
多核
多进程:相对浪费资源
多线程:更加节省资源
代码验证
# 计算密集型
# from multiprocessing import Process
# from threading import Thread
# import os,time
#
#
# def work():
# res = 0
# for i in range(10000000):
# res *= i
#
# if __name__ == '__main__':
# l = []
# print(os.cpu_count()) # 获取当前计算机CPU个数
# start_time = time.time()
# for i in range(12):
# p = Process(target=work) # 1.4679949283599854
# t = Thread(target=work) # 5.698534250259399
# t.start()
# # p.start()
# # l.append(p)
# l.append(t)
# for p in l:
# p.join()
# print(time.time()-start_time)
# IO密集型
from multiprocessing import Process
from threading import Thread
import os,time
def work():
time.sleep(2)
if __name__ == '__main__':
l = []
print(os.cpu_count()) # 获取当前计算机CPU个数
start_time = time.time()
for i in range(4000):
# p = Process(target=work) # 21.149890184402466
t = Thread(target=work) # 3.007986068725586
t.start()
# p.start()
# l.append(p)
l.append(t)
for p in l:
p.join()
print(time.time()-start_time)
7.3.12、总结
-
进程与线程的优缺点
-
进程
- 优点：可以并发执行，可以实现多核运算，爱计算密集型程序效果显著
- 缺点：开启多个进程会造成资源占用
-
线程
- 优点：节省内存空间，在IO密集型效果显著，因为在线程执行的时候需要抢到GIL锁才能继续工作，IO会让抢到的线程主动释放锁，加快程序的执行，看上去是实现了并发。
- 缺点：不能并发执行
-
-
通常可以多进程多线程结合使用，及利用了多核优势，有减少了消耗资源。
7.4、杂碎知识点
7.4.1、死锁与递归锁
-
死锁：程序中出现多个锁操作容易造成死锁现象
from threading import Thread,Lock import time # 实例化两个锁对象 a = Lock() b = Lock() class MyThread(Thread): def run(self): self.func1() self.func2() def func1(self): a.acquire() # 10个线程去抢和这个锁 print(self.name) b.acquire() # 抢到a的才能抢b print(self.name) b.release() a.release() # 施放a的时候 线程2瞬间抢到了a开始执行 def func2(self): b.acquire() # 线程1抢到b和线程2互相卡死，因为需要对方的锁才能施放自己的锁 print(self.name) time.sleep(2) a.acquire() print(self.name) a.release() b.release() for i in range(10): t = MyThread() t.start() -
递归锁
""" 递归锁的特点 可以被连续的acquire和release 但是只能被第一个抢到这把锁执行上述操作 它的内部有一个计数器 每acquire一次计数加一 每realse一次计数减一 只要计数不为0 那么其他人都无法抢到该锁 """ from threading import Thread,Lock import time # 实例化两个锁对象 a = b = RLock() class MyThread(Thread): def run(self): self.func1() self.func2() def func1(self): a.acquire() # 10个线程去抢和这个锁 print(self.name) b.acquire() # 抢到a的才能抢b print(self.name) b.release() a.release() # 施放a的时候 线程2瞬间抢到了a开始执行 def func2(self): b.acquire() # 线程1抢到b和线程2互相卡死，因为需要对方的锁才能施放自己的锁 print(self.name) time.sleep(2) a.acquire() print(self.name) a.release() b.release() for i in range(10): t = MyThread() t.start()
7.4.2、信号量
-
信号量在不同的阶段可能对应的不同的技术点，在并发编程中，信号量指的是锁。
from threading import Thread, Semaphore import time import random sm = Semaphore(5) # 括号内写数字 写几就表示开设几个坑位 # 内置方法和锁一样，抢和施放 # 区别在于信号量可以规定一次性抢锁的最大数量 def task(name): sm.acquire() print('%s 正在蹲坑'% name) time.sleep(random.randint(1, 5)) sm.release() if __name__ == '__main__': for i in range(20): t = Thread(target=task, args=('伞兵%s号'%i, )) t.start()
7.4.3、Event事件
-
一些进程 / 线程遇到等待另外一些进程 / 线程运行完毕之后才能运行，类似发射信号。
from threading import Thread, Event import time event = Event() # 造了一个红绿灯 def light(): print('红灯亮着的') time.sleep(3) print('绿灯亮了') # 告诉等待红灯的人可以走了 event.set() def car(name): print('%s 车正在灯红灯'%name) event.wait() # 等待别人给你发信号 print('%s 车加油门飙车走了'%name) if __name__ == '__main__': t = Thread(target=light) t.start() for i in range(20): t = Thread(target=car, args=('%s'%i, )) t.start()
7.4.4、三种队列
-
队列：先进先出
import queue q = queue.Queue(3) q.put(1) q.put(2) q.put(3) print(q.empty()) # 判断队列是否为空 print(q.full()) # 判断队列是否为满 q.get() q.get() q.get() q.get(timeout=3) # 等待3秒再取数据，如果没有就报错 q.get_nowait() # 不等待，没有数据就报错 -
堆栈：先进后出
import queue q = queue.LifoQueue(3) # last in first out q.put(1) q.put(2) q.put(3) print(q.get()) >>> 3 -
自定义优先级
import queue q = queue.PriorityQueue(3) # 上传数据时要先上传一个该数字排名，排名小的现出来 q.put(('5',1)) q.put(('0',1)) q.put(('-1',1)) print(q.get_nowait()) >>> ('-1',1)
7.4.5、进程池和线程池（重点）
-
概念：之前在tcp实现并发的时候我们是来一个用户就启用一个线程或者进程去为用户服务 但是计算机的硬件资源目前还无法支持我们无限制的开发线程 所以用到了池的概念 池相当于缓冲地带，让我们可以保证计算机在正常运行的情况下最大限度的利用它 它降低了程序的运行效率，但是保证了计算机的安全 如果把计算机比喻成一个小池子你限定了池子最大容量是1，你要喂食，池子就会先产生一条鱼，给你喂，其他人想喂就得等你结束，过来喂的是同一条鱼 而如果不用池的概念去限定，每个人来池子都会给人产生一条鱼来服务，鱼多了，池子就炸了。
-
基本使用
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor import time import os # pool = ThreadPoolExecutor(5)# 线程池里只有5个线程 pool = ProcessPoolExecutor(2)# 进程池里只有5个进程 # 括号内可以传数字 不传的话默认会开设当前计算机cpu个数五倍的线程 # 池子造出来之后 里面会固定存在五个线程 # 这个五个线程不会出现重复创建和销毁的过程 # 池子的使用非常的简单 # 你只需要将需要做的任务往池子中提交即可 自动会有人来服务你 def text(n): print(os.getpid()) time.sleep(3) return n**n def callback(n): print(n.result()) if __name__ == '__main__': res = pool.submit(text,2) # 返回值是一个对象 # print('主') # 异步提交,判断异步的方式，在任务提交后得到返回值之前能不能执行代码 # print(res.result()) # 得到的是提交任务的返回值 t_list = [] for i in range(10): pool.submit(text,i).add_done_callback(callback) # 自定义异步回调机制，在任务得到返回值的时候直接调用里面的函数 # 这种回调机制可以想象为，在提交任务后，直接运行下面的代码，什么时候有返回值了，会立刻调用该方法，相当于埋下了定时炸弹，返回值来了就触发 # res = pool.submit(text,i).result() # 这种得到结果的方式是同步 # t_list.append(res) # pool.shutdown() # 关闭所有线程 # for i in t_list: # print(i)
7.4.6、协程
-
进程：资源单位
-
线程：执行单位
-
协程：程序员意淫出来的
- 为了在多线程实现并发，我们在多线程中出现IO操作都切换走，去执行其他线程，这样就会让计算机看起来一直再运行没有中断过。从而提升了程序的运行效率。
7.4.7、gevent模块
from gevent import monkey;monkey.patch_all()
# 猴子补丁，用来检测程序里出现的io操作
import time
from gevent import spawn
def a():
print('a')
time.sleep(2)
print('a end')
def b():
print('b')
time.sleep(4)
print('b end')
start = time.time()
g1 = spawn(a)
g2 = spawn(b)
g1.join()
g2.join()# 等待任务执行完再执行后面的代码
print(time.time()-start) # 4.015194654464722 实现了io时间切换操作，用户只需等待最长的任务时间
7.4.8、协程实现TCP并发
#服务端
import socket
from gevent import monkey;monkey.patch_all()
from gevent import spawn
def communication(conn):
while True:
try:
msg = conn.recv(1024)
if len(msg) == 0:break
conn.send(msg.upper())
except Exception as e:
print(e)
break
conn.close()
def sever(ip,port):
s = socket.socket()
s.bind((ip, port))
s.listen(5)
while True:
conn,addr = s.accept()
communication(conn)
if __name__ == '__main__':
g = spawn(sever,'127.0.0.1',8080)
g.join()
# 客户端
import socket
from threading import Thread,current_thread
def client():
s = socket.socket()
s.connect(('127.0.0.1', 8080))
n = 0
while True:
msg = '%s say hello %s' % (current_thread().name, n)
n += 1
s.send(msg.encode('utf-8'))
data = s.recv(1024)
print(data.decode('utf-8'))
if __name__ == '__main__':
for i in range(50):
t = Thread(target=client)
t.start()
7.5、IO模型
7.5.1、IO模型简介
Stevens在文章中一共比较五种IO Model：
-
blocking IO 阻塞IO
-
nonblocking IO 非阻塞IO
-
IO multiplexing IO IO多路复用
-
signal driver IO 信号驱动IO
-
asynchronous IO 异步IO
由于signal driver IO（信号驱动IO）在实际上并不常用，所以主要介绍其余四种IO model。
常见的网络阻塞状态：recv、accept
7.5.2、阻塞IO
import socket
server = socket.socket()
server.bind(('127.0.0.1',8080))
server.listen(5)
while True:
conn, addr = server.accept()
while True:
try:
data = conn.recv(1024)
if len(data) == 0:break
print(data)
conn.send(data.upper())
except ConnectionResetError as e:
break
conn.close()
7.5.3、非阻塞IO
# 服务端
import socket
sever = socket.socket()
sever.bind(('127.0.0.1',8080))
sever.listen(5)
sever.setblocking(False)
# 把服务端中的io延迟都改成非阻塞态，直接运行后面的代码
# 原来的io是为了防止报错，让我们停住，现在改成非阻塞了，就要在每一个io前抓取错误
r_list = []
del_list = []
while True:
try:
conn,addr = sever.accept()
r_list.append(conn)
except BlockingIOError:
for conn in r_list:
try:
data = conn.recv(1024)
if len(data) == 0:
del_list.append(conn)
conn.close()
continue
conn.send(data.upper())
except BlockingIOError:
continue
except ConnectionResetError:
del_list.append(conn)
conn.close()
for conn in del_list:
r_list.remove(conn)
del_list.clear()
# 客户端
import socket
s = socket.socket()
s.connect(('127.0.0.1',8080))
while True:
s.send('hz is nb'.encode('utf-8'))
data = s.recv(1024)
print(data)
7.5.4、IO多路复用
IO 多路复用本质上是操作系统帮我们检测任务的返回值，我们同样需要把程序中的阻塞态改为非阻塞态。在监管对象只有一个的时候，它的效率还没有阻塞IO快，因此，IO多路复用用于多个对象运行。
# 服务端
import socket
import select
s = socket.socket()
s.bind(('127.0.0.1',8082))
s.listen(5)
s.setblocking(False)
r_list = [s]
while True:
r, w, x = select.select(r_list, [], [])
# 通过select帮我们监测对象的执行
for i in r:
# 不同的对象执行不同的代码
if i is s:
conn,addr = i.accept()
r_list.append(conn)
else:
try:
data = i.recv(1024)
if len(data) == 0:
i.close()
r_list.remove(i)
continue
i.send(data.upper())
except ConnectionResetError:
i.close()
r_list.remove(i)
# 客户端
import socket
c = socket.socket()
c.connect(('127.0.0.1',8082))
while True:
c.send(b'hz is nb')
data = c.recv(1024)
print(data)
7.5.5、异步IO
"""
异步IO模型是所有模型中效率最高的 也是使用最广泛的
相关的模块和框架
模块:asyncio模块
异步框架:sanic tronado twisted
速度快！！！
"""
import threading
import asyncio
@asyncio.coroutine
def hello():
print('hello world %s'%threading.current_thread())
yield from asyncio.sleep(1) # 换成真正的IO操作
print('hello world %s' % threading.current_thread())
loop = asyncio.get_event_loop()
tasks = [hello(),hello()]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()
7.6、回调函数
-
作用：根据每个线程的执行速率，执行完毕后直接执行下一个函数，避免了统一结束，统一再执行下一个函数的情况。
-
回调函数：无法直接回收返回值
-
回调函数要求传入的必须是一个对象，即不能是已经经过result()的结果，也就是不能使用map方法回调。
ret.add_done_callback(函数名) # 要在ret对应的任务执行完毕之后，直接继续执行add_done_callback绑定的函数中的内容，并且ret的结果会作为参数返回给绑定的函数
