并发编程
目录
网络并发
同步与异步
概念: 用于描述任务的提交状态
同步：提交完任务之后原地等待任务的结果 期间不做任何事
要么成功都成功 要么失败都失败 两个任务的状态可以保持一致
异步: 提交完任务之后不原地等待直接去做其他事情 结果自动提醒
至于被依赖的任务最终是否真正完成，依赖他的任务无法确定
阻塞与非阻塞
概念: 阻塞与非阻塞这两个概念与程序（线程）等待消息通知（无所谓同步或者异步）时的状态有关。
也就是说阻塞与非阻塞主要是程序（线程）等待消息通知时的状态角度来说的
执行状态：
阻塞 : ---阻塞态
非组塞: ---就绪态 运行态
同步异步与阻塞非阻塞
同步阻塞（效率最低）
可以想象为：在银行排队 并且在队伍中不做任何事
同步非阻塞
在银行排队 并且在队伍中做点其他事情
异步阻塞
取号 在旁边座位上等着叫号 期间不做事 实际上效率
异步非阻塞（效率最高）
取号 在旁边的座位上等待叫号 期间为所欲为
创建进程的多种方式
创建进程的本质：在内存中申请一块内存空间运行相应的程序代码
1.双击桌面程序图标
2.通过代码创建进程
强调：不同的操作系统创建进程的要求不一样
在Windows中穿甲进程是以导入模块的方式进行 所以创建进程的代码必须写在__main__子代码中
否则会直接报错 因为在无限制创建进程
在linux和mac中创建进程是直接拷贝一份源代码然后执行 不需要写下__main__子代码中
'''----------------第一种创建进程的方法---------------'''
from multiprocessing import Process
import time
def task(name):
print(f'{name}正在运行')
time.sleep(3)
print(f'{name}运行结束')
if __name__ == '__main__':
p = Process(target=task, args=('jason',)) # 创建一个进程对象
p.start() # 告诉操作系统创建一个进程（异步操作）
# task('jason') # 普通函数调用是同步操作
print('主')
'''----------------第二种创建进程的方法---------------'''
class MyProcess(Process):
def __init__(self, name):
super().__init__()
self.name = name
def run(self):
print(f'{self.name}正在运行')
time.sleep(5)
print(f'{self.name}运行结束')
if __name__ == '__main__':
obj = MyProcess('jason')
obj.start()
print('主进程')
"""
补充说明：
创建进程的代码在不同的操作系统中 底层原理有区别！！！
在windows中 创建进程类似导入模块
if __name__ == '__mian__': 启动脚本
在mac、linux中 创建进程类似于直接拷贝
不需要启动脚本 但是为了兼容性 也可以使用
代码的走向：相当于在一个内存空间有一个主代码， 它是从上至下的走的， 遇到star(),单独再开一个进程，然后紧接着再走它自己的代码
"""
join方法
1. join:主进程等待子进程运行结束之后再运行
2. 推导步骤
直接在主进程代码中添加time.sleep(),不合理，因为无法准确把握子进程执行的时间
join方法， 很合理，它是等待子进程结束以后才会运行
def task(name, n):
print(f'{name}正在运行')
time.sleep(n)
print(f'{name}运行结束')
if __name__ == '__main__':
p1 = Process(target=task, args=('jason', 1)) # args就是通过元组的形式给函数传参
p2 = Process(target=task, args=('kevin', 2)) # 也可以通过kwargs={'name':'jason', 'n':1} 太麻烦 没必要
p3 = Process(target=task, args=('jerry', 3))
start_time = time.time()
p1.start()
p2.start()
p3.start()
p1.join()
p2.join()
p3.join()
end_time = time.time() - start_time
print('总耗时:%s' % end_time) # 三秒多
print('主进程')
'''
p1.start()
p1.join()
p2.start()
p2.join()
p3.start()
p3.join()
end_time = time.time() - start_time
print('总耗时:%s' % end_time) # 六秒多
print('主进程')
'''
'''一定要看准join的执行位置 以及多任务情况下等待的目标'''
进程间数据隔离
'''
多个进程数据彼此之间默认是互相隔离的
如果真的想交互，需要借助于'管道'或者'队列'
'''
from multiprocessing import Process
money = 100
def task():
global money
money = 666
print('子进程打印的money', money)
if __name__ == '__main__':
p = Process(target=task)
p.start()
p.join()
print('父进程打印的money', money )
IPC机制
1.消息队列
1.相当于一个临时或者是公共的保存数据的地方，进程之间可以通过它来实现交互，可以向它里面放入数据，也可以取出数
2.队列可以再本地上，也可以在网络上，可以单独拿出来变成一个程序，'消息队列'是存在在网络上的，它是由服务器维护的
2.进程间通信IPC机制
进程间通信用到的可以是管道也可以是队列，但是管道没有队列好用
2.1什么是对列
它的特点就是 先进先出
代码如下：
from multiprocessing import Queue
# 1.创建队列对象
q = Queue(3) # 括号内指定队列可以容纳的数据个数 默认是：2147483647
# 2.往队列添加数据
q.put('张')
q.put('询')
q.put('彬')
q.put('吃屁') # 超出数据存放极限 那么程序一致处于阻塞态 直到队列中有数据被取出
print(q.full()) # 判断队列是否已经存满
# 3.从队列中取数据
print(q.get_nowait())
print(q.get_nowait())
print(q.get_nowait()) # 队列中如果没有数据可取 直接报错
print(q.get())
print(q.empty()) # 判断队列是否已经空了，返回的是布尔值
print(q.get())
print(q.get())
print(q.empty())
print(q.get()) # 超出数据获取极限 那么程序一致处于阻塞态 直到队列中有数据被添加
"""
q.full() # 判断队列是否已经存满
q.empty() # 判断队列是否已经空了
q.get_nowait() # 队列中如果没有数据可取
上述方法在多进程下不能准确使用(失效)!!!
"""
IPC机制
1.主进程与子进程通信
2.子进程与子进程通信
from multiprocessing import Queue, Process
def procedure(q):
q.put('子进程procedure往队里中添加了数据')
def consumer(q):
print('子进程的consumer从队列中获取数据', q.get())
if __name__ == '__main__':
q = Queue() # 在主进程中产生q对象 确保所有的子进程使用的是相同的q
p1 = Process(target=procedure, args=(q,))
p2 = Process(target=consumer, args=(q,))
p1.start()
p2.start()
print('主进程')
生产者消费者模型
生成者
产生数据
消费者
处理数据
"""
回忆过去 爬取红牛分公司
生产者:获取网页数据的代码(函数)
爬
消费者:从网页数据中筛选出符合条件的数据(函数)
筛选
完整的生产者消费者模型至少有三个部分
生产者
消息队列/数据库
消费者
"""
进程对象相关的方法
1.查看进程号
from multiprocessing import current_process
import os
current_process().pid
os.getpid()
os.getppid()
2.销毁子进程
p1.terminate()
ps:计算机操作系统都有对应的命令可以直接杀死进程
3.判断进程是否存活
p1.is_alive()
守护进程
如何理解守护
伴随着守护对象的存活而存活 死亡而死亡
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=('基佬',))
# p.daemon = True # 将子进程设置为守护进程:主进程代码结束 子进程立刻结束
p.start()
p.daemon = True # 必须在start之前执行
print('天子Jason寿终正寝!!!')
僵尸进程与孤儿进程
僵尸进程
进程执行完毕后并不会立刻销毁所有的数据 会有一些信息短暂保留下来
比如 进程号、进程执行时间、进程消耗功率等给父进程查看
ps:所有的进程都会变成僵尸进程
孤儿进程
子进程正常进行 父进程意外死亡 操作系统针对孤儿进程会派遣福利院管理
互斥锁前戏
模拟抢票
查票
买票
查票
买票
from multiprocessing import Process
import time
import json
import random
# 查票
def search(name):
with open(r'data.json', 'r', encoding='utf8') as f:
data = json.load(f)
print('%s在查票 当前余票为:%s' % (name, data.get('ticket_num')))
# 买票
def buy(name):
# 再次确认票
with open(r'data.json', 'r', encoding='utf8') as f:
data = json.load(f)
# 模拟网络延迟
time.sleep(random.randint(1, 3))
# 判断是否有票 有就买
if data.get('ticket_num') > 0:
data['ticket_num'] -= 1
with open(r'data.json', 'w', encoding='utf8') as f:
json.dump(data, f)
print('%s买票成功' % name)
else:
print('%s很倒霉 没有抢到票' % name)
def run(name):
search(name)
buy(name)
if __name__ == '__main__':
for i in range(10):
p = Process(target=run, args=('用户%s'%i, ))
p.start()
"""
多进程操作数据很可能会造成数据错乱>>>:互斥锁
互斥锁
将并发变成串行 牺牲了效率但是保障了数据的安全
"""
互斥锁
1.锁
锁--multiprocess.Lock
加锁可以保证多个进程修改同一块数据时，同一时间只能有一个任务可以进行修改
即串行的修改，虽然速度是慢了，但牺牲了速度却保证了数据安全。
虽然可以用文件共享数据实现进程间通信，但问题是：
1.效率低（共享数据基于文件，而文件是硬盘上的数据）
2.需要自己加锁处理
因此我们最好找寻一种解决方案能够兼顾：
1、效率高（多个进程共享一块内存的数据）
2、帮我们处理好锁问题。
这就是mutiprocessing模块为我们提供的基于消息的IPC通信机制：队列和管道。
队列和管道都是将数据存放于内存中
队列又是基于（管道+锁）实现的，可以让我们从复杂的锁问题中解脱出来
我们应该尽量避免使用共享数据，尽可能使用消息传递和队列，避免处理复杂的同步和锁问题，而且在进程数目增多时，往往可以获得更好的可获展性。
2.如何使用互斥锁
互斥锁
将并发变成串行 虽然牺牲了程序的执行效率但是保证了数据安全
from multiprocessing import Process, Lock
mutex = Lock()
mutex.acquire() # 抢锁
mutex.release() # 释放锁
3.强调
互斥锁只应该出现在多个程序操作数据的地方 其他位置尽量不要加
ps:以后我们自己处理锁的情况很少 只需要知道锁的功能即可
4.其他锁
行锁、表锁、乐观锁、悲观锁
5.代码实例(抢票系统)
from multiprocessing import Process, Lock
import time
import json
import random
# 查票
def search(name):
with open(r'data.json', 'r', encoding='utf8') as f:
data = json.load(f)
print('%s在查票 当前余票为:%s' % (name, data.get('ticket_num')))
# 买票
def buy(name):
# 再次确认票
with open(r'data.json', 'r', encoding='utf8') as f:
data = json.load(f)
# 模拟网络延迟
time.sleep(random.randint(1, 3))
# 判断是否有票 有就买
if data.get('ticket_num') > 0:
data['ticket_num'] -= 1
with open(r'data.json', 'w', encoding='utf8') as f:
json.dump(data, f)
print('%s买票成功' % name)
else:
print('%s很倒霉 没有抢到票' % name)
def run(name, mutex):
search(name)
mutex.acquire() # 抢锁
buy(name)
mutex.release() # 释放锁
if __name__ == '__main__':
# 1.先产生锁
mutex = Lock()
for i in range(10):
p = Process(target=run, args=('用户%s' % i, mutex))
p.start()
线程理论
进程是资源单位
进程相当于是车间 进程负责给内部的线程提供相应的资源
线程是执行单位
线程相当于是车间里面的流水线 线程负责执行真正的功能
1.一个进程至少含有一个线程
2.多进程与多线程的区别
多进程
需要申请内存空间 需要拷贝全部代码 资源消耗大
多线程
不需要申请内存空间 也不需要拷贝全部代码 资源消耗小
3.同一个进程下多个线程之间资源共享
创建线程的两种方式
from threading import Thread
from multiprocessing import Process
import time
# def task(name):
# print(f'{name}正在运行')
# time.sleep(3)
# print(f'{name}运行结束')
"""
开设线程不需要完整拷贝代码 所以无论什么系统都不会出现反复操作的情况
也不需要在启动脚本中执行 但是为了兼容性和统一性 习惯在启动脚本中编写
"""
# t = Thread(target=task, args=('jason',))
# t.start()
# print('主线程')
# if __name__ == '__main__':
# t = Thread(target=task, args=('jason',))
# t.start()
# print('主线程')
class MyThread(Thread):
def __init__(self, name):
super().__init__()
self.name = name
def run(self):
print(f'{self.name}正在运行')
time.sleep(3)
print(f'{self.name}运行结束')
obj = MyThread('jason')
obj.start()
print('主线程')
线程的诸多特性
1.多线程实现TCP服务端并发
-------------客户端----------
import socket
client = socket.socket()
client.connect(('127.0.0.1', 8080))
while True:
client.send(b'aaaaa')
data = client.recv(1024)
print(data.decode('utf8'))
---------------服务端-----------
import socket
from threading import Thread
server = socket.socket()
server.connect(('127.0.0.1', 8080))
server.listen(5)
def talk(sock):
while True:
data = sock.recv(1024)
print(data.decode('utf8'))
sock.send(data.upper())
while True:
sock, addr = server.accept()
p = Thread(target=talk, args=(sock,))
p.start()
'''
比多进程更加简单方便 消耗的资源更少
ps:课下使用多进程或者多线程对比(任务管理器)
'''
2.join方法
主线程等到子线程运行结束之后再运行
from threading import Thread
import time
def task():
print('正在执行')
time.sleep(3)
print('运行结束')
t = Thread(target=task)
t.start()
t.join()
print('主线程')
3.同一个进程下线程间数据共享
"""同一个进程下线程间数据共享"""
from threading import Thread
money = 100
def func():
global money
money = 666
t = Thread(target = func)
t.start()
t.join() # 确保线程运行完毕 再查找money 结果更具有说服性
print(money)
4.线程对象相关方法
1.进程号
同一个进程下开设的多个线程拥有相同的进程号
2.线程名
from threading import Thread, current_thread
current_thread().name
主:MainThread 子:Thread-N
3.进程下的线程数
active_count()
5.守护线程
守护线程伴随着被守护的线程的结束而结束
from threading import Thread
import time
def task():
print('子线程运行task函数')
time.sleep(3)
print('子线程运行task结束')
t = Thread(target=task)
# t.daemon = True
t.start()
# t.daemon = True
print('主线程')
"""
进程下所有的非守护线程结束 主线程(主进程)才能真正结束!!!
"""
GIL全局解释器锁
储备知识
1.python解释器也是由编程语言写出来的
Cpython 用C写出来的
Jpython 用Java写出来的
Pypython 用python写出来的
ps:最常用的就是Cpython(默认)
# 官方文档对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.)
"""
1.GIL的研究是Cpython解释器的特点 不是python语言的特点
2.GIL本质也是一把互斥锁
3.GIL的存在使得同一个进程下的多个线程无法同时执行(关键)
言外之意:单进程下的多线程无法利用多核优势 效率低!!!
4.GIL的存在主要是因为cpython解释器中垃圾回收机制不是线程安全的
"""
1.误解:python的多线程就是垃圾 利用不到多核优势
python的多线程确实无法使用多核优势 但是在IO密集型的任务下是有用的
2.误解:既然有GIL 那么以后我们写代码都不需要加互斥锁
不对 GIL只确保解释器层面数据不会错乱(垃圾回收机制)
针对程序中自己的数据应该自己加锁处理
3.所有的解释型编程语言都没办法做到同一个进程下多个线程同时执行
ps:我们平时在写代码的时候 不需要考虑GIL 只在学习和面试阶段才考虑!!!
1.GIL是否存在
from threading import Thread
money = 100
def task():
global money
money -= 1
# 新增
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)
'''
for循环是一次性全部触发
等待所有的线程运行结束以后，查看money是多少
因为start是一个异步操作，执行完for循环的时候它会直接执行print，但是此时线程还没有执行完，所有还需要进一步优化
join()方法：主线程等待子线程运行结束
新增内容：
每一个t都是不一样的，列表里的每一个t都是不一样的，类似于列表里的t指向了不同的子线程
'''
2.针对不同的数据应该加不同的锁处理
'''
GIL它只影响的是解释器层面的数据安全，不会影响应用程序自己的数据安全
问题：
是不是有了GIL以后只要涉及到了并发操作同一个数据，就不需要加锁等处理？？
并不是，GIL不管程序里面的数据怎么变，只保证的是垃圾回收装置不会误删数据，其他情况要保证数据的不错乱需要自己加锁
也就是GIL的存在与否并不会影响所写的代码，在程序运行期间自己想修改的那个数据的安全性需要自己去加锁
尤其是在网络延迟的情况下，还有我们平常写的代码中大多数会进入一个IO操作情况下，需要我们自己加锁
GIL释放的情况：
代码运行结束
进入IO操作
time.sleep是一个IO操作，遇到它的时候被迫会把GIL放出来，此时其他线程就会去抢，然后就是会一直这样，每个子线程都-1，最后输出的就是99
生成锁：
mutex.acquire()
mutex.release()
'''
3.GIL与普通互斥锁
问题：
是不是有了GIL以后只要涉及到了并发操作同一个数据，就不需要加锁等处理？？
并不是，GIL不管程序里面的数据怎么变，只保证的是垃圾回收装置不会误删数据，其他情况要保证数据的不错乱需要自己加锁
也就是GIL的存在与否并不会影响所写的代码，在程序运行期间自己想修改的那个数据的安全性需要自己去加锁
尤其是在网络延迟的情况下，还有我们平常写的代码中大多数会进入一个IO操作情况下，需要我们自己加锁
import time
from threading import Thread,Lock
num = 100
def task(mutex):
global num
mutex.acquire()
count = num
time.sleep(0.1)
num = count - 1
mutex.release()
mutex = Lock()
t_list = []
for i in range(100):
t = Thread(target=task,args=(mutex,))
t.start()
t_list.append(t)
for t in t_list:
t.join()
python多线程是否有用
需要分情况
情况1：单个CPU、多个CPU
情况2：IO密集型(代码有IO操作)、计算密集型(代码没有IO)
1.单个CPU
IO密集型
多进程
申请额外的空间 消耗更多的资源
多线程
消耗资源相对较少 通过多道技术
ps:多线程有优势!!!
计算密集型
多进程
申请额外的空间 消耗更多的资源(总耗时+申请空间+拷贝代码+切换)
多线程
消耗资源相对较少 通过多道技术(总耗时+切换)
ps:多线程有优势!!!
2.多个CPU
IO密集型
多进程
总耗时(单个进程的耗时+IO+申请空间+拷贝代码)
多线程
总耗时(单个进程的耗时+IO)
ps:多线程有优势!!!
计算密集型
多进程
总耗时(单个进程的耗时)
多线程
总耗时(多个进程的综合)
ps:多进程完胜!!!
from threading import Thread
from multiprocessing import Process
import os
import time
def work():
# 计算密集型
res = 1
for i in range(1, 100000):
res *= i
if __name__ == '__main__':
# print(os.cpu_count()) # 12 查看当前计算机CPU个数
start_time = time.time()
# p_list = []
# for i in range(12): # 一次性创建12个进程
# p = Process(target=work)
# p.start()
# p_list.append(p)
# for p in p_list: # 确保所有的进程全部运行完毕
# p.join()
t_list = []
for i in range(12):
t = Thread(target=work)
t.start()
t_list.append(t)
for t in t_list:
t.join()
print('总耗时:%s' % (time.time() - start_time)) # 获取总的耗时
"""
计算密集型
多进程:5.665567398071289
多线程:30.233906745910645
"""
def work():
time.sleep(2) # 模拟纯IO操作
if __name__ == '__main__':
start_time = time.time()
# t_list = []
# for i in range(100):
# t = Thread(target=work)
# t.start()
# for t in t_list:
# t.join()
p_list = []
for i in range(100):
p = Process(target=work)
p.start()
for p in p_list:
p.join()
print('总耗时:%s' % (time.time() - start_time))
"""
IO密集型
多线程:0.0149583816528320
多进程:0.6402878761291504
"""
死锁现象
两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁现象
"""
虽然我们已经掌握了互斥锁的使用
先抢锁 后释放锁
但是在实际项目尽量少用(你也不会用!!!)
"""
from threading import Thread, Lock
import time
mutexA = Lock() # 类名加括号每执行一次就会产生一个新的对象
mutexB = Lock() # 类名加括号每执行一次就会产生一个新的对象
'''
Lock()是一个类，类名加括号，每执行一次就会产生一个对象
类名加括号每执行一次就会产生一个新的对象，可以用单例模式实现
'''
class MyThread(Thread):
def run(self):
self.func1()
self.func2()
def func1(self):
mutexA.acquire()
print(f'{self.name}抢到了A锁')
mutexB.acquire()
print(f'{self.name}抢到了B锁')
mutexB.release()
print(f'{self.name}释放了B锁')
mutexA.release()
print(f'{self.name}释放了A锁')
def func2(self):
mutexB.acquire()
print(f'{self.name}抢到了B锁')
time.sleep(1)
mutexA.acquire()
print(f'{self.name}抢到了A锁')
mutexA.release()
print(f'{self.name}释放了A锁')
mutexB.release()
print(f'{self.name}释放了B锁')
for i in range(10):
t = MyThread()
t.start()
信息量
互斥锁同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据。
Semaphore管理一个内置的计数器，
每当调用acquire()时内置计数器-1；
调用release() 时内置计数器+1；
计数器不能小于0；当计数器为0时，acquire()将阻塞线程直到其他线程调用release()
锁信号量与进程池的概念很像，但是要区分开，信号量涉及到加锁的概念。
信号量本质也是互斥锁 只不过它是多把锁
强调:
信号量在不同的知识体系中 意思可能有区别
在并发编程中 信号量就是多把互斥锁
在django中 信号量指的是达到某个条件自动触发(中间件)
...
我们之前使用Lock产生的是单把锁
类似于单间厕所
信号量相当于一次性创建多间厕所
类似于公共厕所
代码实例：
from threading import Thread, Lock, Semaphore
import time
import random
sp = Semaphore(5) # 一次性产生五把锁
class MyThread(Thread):
def run(self):
sp.acquire()
print(self.name)
time.sleep(random.randint(1, 3))
sp.release()
for i in range(20):
t = MyThread()
t.start()
event事件
子进程\子线程之间可以彼此等待彼此
eg:子A运行到某一个代码位置后'发信号'告诉子B开始运行
在多线程环境中，每个线程的执行一般是独立的，如果一个线程的执行依赖于另一个线程的状态，那么就有必要引入某种标志位来进行判断，event就相当于一个全局的标志位。
event常用于主线程控制其他线程的执行。
创建一个event对象：
event = threading.Event()
event对象的方法：
1. event.isSet() 或 event.is_set(), 返回event对象的bool值，event对象的初始bool值是False.
2. event.wait() 如果上面是True, 啥也不做，往下执行，如果上面是False, 则阻塞线程. wait(num)为超时设置，超过num秒，继续往下执行。
3. event.set() 设置event对象True
4. event.clear() 恢复为False
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)
t = Thread(target=light)
t.start()
for i in range(20):
t = Thread(target=car, args=('熊猫PRO%s' % i,))
t.start()
进程池与线程池
多进程 多线程
在实际应用中是不是可以无限制的开进程和线程
肯定不可以!!! 会造成内存溢出受限于硬件水平
我们在开设多进程或者多线程的时候 还需要考虑硬件的承受范围
池
降低程序的执行效率 保证计算机硬件的安全
进程池
提前创建好固定个数的进程供程序使用 后续不会再创建
线程池
提前创建好固定个数的线程供程序使用 后续不会再创建
submit(函数名,实参1,实参2,...)
from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
from threading import current_thread
import os
import time
# pool = ThreadPoolExecutor(5) # 固定产生五个线程
pool = ProcessPoolExecutor(5) # 固定产生五个线程
def task(n):
# print(current_thread().name)
print(os.getpid())
# print(n)
time.sleep(1)
return '返回的结果'
def func(*args, **kwargs):
print('func', args, kwargs)
print(args[0].result())
if __name__ == '__main__':
for i in range(20):
# res = pool.submit(task,123) # 朝池子中提交任务(异步)
# print(res.result()) # 同步
# pool.submit(task, 123).add_done_callback(func)
"""异步回调:异步任务执行完成后有结果就会自动触发该机制"""
pool.submit(task, 123).add_done_callback(func)
'''
异步回调：
先向池子里提交任务，不用等待它什么时候执行完，只要池子里的任务执行完以后，就会立即将结果返回，触发func
'''
协程
进程:资源单位
线程:执行单位
协程:单线程下实现并发(效率极高)
在代码层面欺骗CPU 让CPU觉得我们的代码里面没有IO操作
实际上IO操作被我们自己写的代码检测 一旦有 立刻让代码执行别的
(该技术完全是程序员自己弄出来的 名字也是程序员自己起的)
核心:自己写代码完成切换+保存状态
协程存在的意义：对于多线程应用，CPU通过切片的方式来切换线程间的执行，线程切换时需要耗时(保存状态，下次继续)。
协程，则只使用一个线程，在一个线程中规定某个代码块执行顺序。
import time
from gevent import monkey;
monkey.patch_all() # 固定编写 用于检测所有的IO操作(猴子补丁)
from gevent import spawn
def func1():
print('func1 running')
time.sleep(3)
print('func1 over')
def func2():
print('func2 running')
time.sleep(5)
print('func2 over')
if __name__ == '__main__':
start_time = time.time()
# func1()
# func2()
s1 = spawn(func1) # 检测代码 一旦有IO自动切换(执行没有io的操作 变向的等待io结束)
s2 = spawn(func2)
s1.join()
s2.join()
print(time.time() - start_time) # 8.01237154006958 协程 5.015487432479858
协程实现TCP服务端并发
import socket
from gevent import monkey;monkey.patch_all() # 固定编写 用于检测所有的IO操作(猴子补丁)
from gevent import spawn
def communication(sock):
while True:
data = sock.recv(1024)
print(data.decode('utf8'))
sock.send(data.upper())
def get_server():
server = socket.socket()
server.bind(('127.0.0.1', 8080))
server.listen(5)
while True:
sock, addr = server.accept() # IO操作
spawn(communication, sock)
s1 = spawn(get_server)
s1.join()
浙公网安备 33010602011771号