目录
一、验证GIL存在
有了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) # [线程1 线程2 线程3 ... 线程100]
for t in t_list:
t.join()
# 等待所有的线程运行结束 查看money是多少
print(money)
'''
线程同时执行，结果不会为 0
上述结果为 0，表明GIL是存在的，线程没有同时执行
'''
二、验证GIL的特点
GIL不会影响程序层面的数据也不会保证它的修改是安全的，要想保证它的修改是安全的得自己加锁
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) # [线程1 线程2 线程3 ... 线程100]
for t in t_list:
t.join()
# 等待所有的线程运行结束 查看money是多少
print(money)
三、验证python多线程是否有用
-
情况一：单个CPU和多个CPU
-
情况二：IO密集型(代码有IO操作)和计算密集型(代码没有IO)
1.单个CPU
| IO密集型 | 计算密集型 | |
|---|---|---|
| 多进程 | 申请额外的空间，消耗更多的资源 | 申请额外的空间，消耗更多的资源（总耗时+申请空间+拷贝代码+切换） |
| 多线程 | 消耗资源相对较少，通过多道技术 | 消耗资源相对较少，通过多道技术（总耗时+切换） |
| 优势 | 多线程有优势 | 多线程有优势 |
2.多个CPU
| IO密集型 | 计算密集型 | |
|---|---|---|
| 多进程 | 总耗时（单个进程的耗时+IO+申请空间+拷贝代码） | 总耗时（单个进程耗时） |
| 多线程 | 总耗时（单个进程耗时+IO） | 总耗时（多个进程的综合） |
| 优势 | 多线程有优势 | 多进程完胜 |
3.代码示例
计算机密集型：
- 多线程：30.233906745910645
- 多进程：5.665567398071289
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)) # 获取总的耗时
IO密集型：
- 多线程：0.0149583816528320
- 多进程：0.6402878761291504
from threading import Thread
from multiprocessing import Process
import os
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()
# 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))
四、死锁现象
互斥锁的使用：先抢锁，后释放锁（实际项目尽量少用）
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()
五、信号量
1.简介
信号量本质：互斥锁，只不过是多把锁
信号量在不同的知识体系里的意思区别：
- 在并发编程中，信号量就是多把互斥锁
- 在Django中，信号量指的是达到某个条件自动触发（中间件）
之前使用Lock产生的是单把锁（类似于单间厕所）
信号量相当于一次性创建多间厕所（类似于公共厕所）
2.代码示例
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事件
子进程/子线程之间可以彼此等待彼此
- 子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.代码实例
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)
八、协程
| 名称 | 属性 |
|---|---|
| 进程 | 资源单位 |
| 线程 | 执行单位 |
| 协程 | 单线程下实现并发（效率极高） |
1.简介
在代码层面欺骗CPU 让CPU觉得我们的代码里面没有IO操作，实际上IO操作被我们自己写的代码检测，一旦有，立刻让代码执行别的(该技术完全是程序员自己弄出来的，名字也是程序员自己起的)
核心：自己写代码完成切换+保存状态
2.代码示例
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服务端并发
Gevent 是一个第三方库，通过gevent实现并发同步或异步编程，在gevent中用到的主要模式是Greenlet, 它是以C扩展模块形式接入Python的轻量级协程。
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()
十、总结
怎么不断的提升程序的运行效率：多进程下开多线程，多线程
下开协程
posted on
