验证GIL的存在、特点、验证python多线程是否有用、死锁现象、信号量、event事件、进程池与线程池、协程
验证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) # 0
ps:加入t_list列表添加线程对象，是为了保证所有的线程执行完了之后，才执行查看最后的money
验证GIL的特点
GIL不会影响程序层面的数据，也不会保证它的修改是安全的，要想保证自己程序的数据安全，得自己加锁
from threading import Thread
import time
money = 100
def task():
global money
tmp = money
time.sleep(0.1)
money = tmp - 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) # 99
from threading import Thread,Lock
import time
money = 100
mutex = Lock()
def task():
mutex.acquire()
global money
tmp = money
time.sleep(0.1)
money = tmp - 1
mutex.release()
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) # 0
验证python多线程是否有用
python的多线程确实无法使用多核优势 但是在IO密集型的任务下是有用的
验证python多线程是否有用，需要分两种情况：第一种：是单个cpu还是多个CPU;第二种：是IO密集型(代码有IO操作)，计算密集型(代码没有IO操作)；根据这两种情况，可得出以下结论
1.单个CPU
1.1 IO密集型：多线程有优势
多进程：申请额外的空间，消耗更多的资源
多线程：消耗资源相对较少，可以通过多道技术，提升CPU的效率
1.2 计算密集型：多线程有优势
多进程：申请额外的空间，消耗更多的资源(总耗时+申请空间+拷贝代码+切换)
多线程：消耗资源相对较少，通过多道技术(总耗时+切换)
2.多个CPU
2.1 IO密集型：多线程有优势
多进程:总耗时(单个进程耗时+IO操作+申请空间+拷贝代码)
多线程:总耗时(单个进程的耗时+IO)
2.2 计算密集型：多进程有优势
多进程:总耗时(单个进程耗时+IO操作+申请空间+拷贝代码)
多线程:总耗时(多个进程的综合)
验证：在多个CPU且IO密集型的情况
在多核CPU且IO密集型的情况下，多线程有优势
多进程：
from multiprocessing import Process
import time
def work():
time.sleep(2) # 模拟纯IO操作
if __name__ == '__main__':
start_time = time.time()
p_list = []
for i in range(100):
p = Process(target=work)
p.start()
p_list.append(p)
for p in p_list:
p.join()
print('总耗时：%s'%(time.time()-start_time)) # 总耗时：5.521599054336548
多线程：
from threading import Thread
import time
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()
t_list.append(t)
for t in t_list:
t.join()
print('总耗时：%s'%(time.time()-start_time)) # 总耗时：2.03155326843261
验证：在多个CPU且计算密集型的的情况
在多个CPU且计算密集型的的情况的情况下，多进程有优势
多进程：
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()) # 8 查看当前计算机cpu的个数
start_time = time.time()
p_list = []
for i in range(12):
p = Process(target=work)
p.start()
p_list.append(p)
for p in p_list:
p.join()
print('总耗时：%s'%(time.time()-start_time)) # 总耗时：9.805726766586304
from threading import Thread
import os
import time
def work():
res = 1
for i in range(1,100000):
res *= i
if __name__ == '__main__':
start_time = time.time()
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)) # 总耗时：42.40727233886719
死锁现象
死锁是指两个或两个以上的进程或线程在执行过程中互相争抢对方的锁，使程序一直处于阻塞的状态。
ps：虽然我们已经掌握了互斥锁的作用，但是在实际项目中尽量少用
from threading import Thread, Lock
import time
mutexA = Lock() # 类名加括号每执行一次就会产生一个新的对象
mutexB = 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()
信号量
信号量本质也是互斥锁，只不过它是多把锁。使用时，导入from threading import Semaphore模块，使用obj = Semaphore(n) 表示一次性创n把锁
from threading import Thread,Semaphore
import time
import random
sp = Semaphore(5)
class My_Thread(Thread):
def run(self):
sp.acquire()
print(self.name)
time.sleep(random.randint(1,3))
sp.release()
for i in range(20):
t = My_Thread()
t.start()
event事件
event时间是指子进程或者子线程之间可以彼此等待彼此
eg:子A运行到某一代码位置后发信号告诉子B开始运行
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()
进程池和线程池
理论
1.在实际应用中，我们不可以无限制的开进程和线程，否则会造成内存溢出受限于硬件水平，我们在开设多进程或者多线程事物时候，还需要考虑硬件的承受范围
2.池：作用是降低程序的执行效率，保证计算机硬件的安全
3.进程池：提前创建好固定个数的进程供程序使用，后续不会在创建
4.线程池：提前创建好固定个数的线程供程序使用，后续不会在创建
5.导入from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor模块，再用submit(函数，实参1，实参2) 往池子中提交任务(异步)
from concurrent.futures import ProcessPoolExecutor
import os
import time
pool = ProcessPoolExecutor(5)
def task():
print(os.getpid())
time.sleep(3)
if __name__ == '__main__':
for i in range(20):
pool.submit(task) # 往池子中提交任务(异步)
结果：
18720 14496 13000 9436 12084(重复打印4次这5个端口号 没有顺序)
需求：使创建的进程获取到task()函数的返回值
from concurrent.futures import ProcessPoolExecutor
import time
pool = ProcessPoolExecutor(5)
def task(name):
print(name)
time.sleep(3)
if __name__ == '__main__':
for i in range(20):
res= pool.submit(task,'nana') # 朝池子中提交任务(异步操作)
# print(res) # <Future at 0x11f18f67390 state=running> * 20次
print(res.result()) # 获取返回值，同步操作
ps:
1.发现：直接用变量名接收打印，获取不到返回值；
2.用变量名.result()的方法可以获取到返回值，但是它是同步操作，执行效率慢
解决：用add_done_callback(func) 给前面任务绑定回调机制，它称之为异步回调：异步任务执行完成后有结果就会自动触发该机制
from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
from threading import current_thread
import os
import time
pool = ProcessPoolExecutor(5)
def task(name):
print(name)
time.sleep(3)
def func(*args,**kwargs):
print('func',args,kwargs)
print(args[0].result()) # None
if __name__ == '__main__':
for i in range(20):
pool.submit(task,'nana').add_done_callback(func) # 给前面任务绑定回调机制
协程
简介
1.进程：是资源单位，负责给内部的线程提供相应的资源
2.线程：是执行单位，负责执行真正的功能
3.协程：是单线程实现并发(效率高)，也就是代码层面上欺骗CPU，让CPU觉得我们的代码里面没有IO操作，实际上是IO操作被我们自己写的代码检查到之后，会立刻执行别的代码(该技术完全是程序员自己弄出来的，名字也是程序员自己起的)
4.核心：自己写代码完成切换+保存状态
应用
导入from gevent import monkey;monkey.patch_all() (固定编写,用于检测所有的IO操作,称作猴子补丁)、from gevent import spawn模块；用spawn(函数)来：检测代码 一旦有IO操作自动切换(执行没有IO的操作，变向的等待IO结束)
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('fun2 over')
if __name__ == '__main__':
start_time = time.time()
s1 = spawn(func1) # 检测代码 一旦有IO操作自动切换(执行没有IO的操作，变向的等待IO结束)
s2 = spawn(func2)
s1.join()
s2.join()
print(time.time()-start_time) # 5.044574737548828
协程实现TCP服务端并发
服务端
import socket
from gevent import monkey;monkey.patch_all()
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()
客服端
import socket
from threading import Thread,current_thread
def client_comm():
client = socket.socket()
client.connect(('127.0.0.1',8080))
while True:
client.send(f'hello {current_thread().name}'.encode('utf8'))
data= client.recv(1024)
print(data.decode('utf8'))
for i in range(100):
t = Thread(target=client_comm)
t.start()
ps：不断提升程序的运行效率是：在多进程下开多线程，在多线程下开协程
浙公网安备 33010602011771号