验证GIL的存在、验证python多线程是否有用、死锁现象、event事件、信号量、进程池与线程池、协程、协程实现TCP服务端并发
验证GIL的存在
-
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指向了不同的子线程 '''
-
针对不同的数据应该加不同的锁处理
''' GIL它只影响的是解释器层面的数据安全，不会影响应用程序自己的数据安全 问题： 是不是有了GIL以后只要涉及到了并发操作同一个数据，就不需要加锁等处理？？ 并不是，GIL不管程序里面的数据怎么变，只保证的是垃圾回收装置不会误删数据，其他情况要保证数据的不错乱需要自己加锁 也就是GIL的存在与否并不会影响所写的代码，在程序运行期间自己想修改的那个数据的安全性需要自己去加锁 尤其是在网络延迟的情况下，还有我们平常写的代码中大多数会进入一个IO操作情况下，需要我们自己加锁 GIL释放的情况： 代码运行结束 进入IO操作 time.sleep是一个IO操作，遇到它的时候被迫会把GIL放出来，此时其他线程就会去抢，然后就是会一直这样，每个子线程都-1，最后输出的就是99 生成锁： mutex.acquire() mutex.release() '''
from threading import Thread import time money = 100 def task(): '''修改部分,再加一个锁''' mutex.acquire() global money tmp = money time.sleep(0.1) money = tmp - 1 mutex.release() ''' 第一个抢到的后面遇到IO操作只是释放了GIL的锁，而里面自己设置的锁还在，所以其他的子线程还是进不去，得等到第一个自己的锁释放掉才可以 ''' # 新增 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)
验证python多线程是否有用
需要分情况
情况1：单个CPU、多个CPU
情况2：IO密集型(代码有IO操作)、计算密集型(代码没有IO)
-
单个cpu
IO密集型 多进程 申请额外的空间 消耗更多的资源 多线程 消耗资源相对较少 通过多道技术 ps:多线程有优势!!! 计算密集型 多进程 申请额外的空间 消耗更多的资源(总耗时+申请空间+拷贝代码+切换) 多线程 消耗资源相对较少 通过多道技术(总耗时+切换) ps:多线程有优势!!! -
多个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()
