GIL以及协程
一、GIL全局解释器锁
'''
python解释器：
- Cpython c语言
- Jpython java
1、GIL：全局解释器锁
- 翻译：在同一个进程下开启的多个线程，同一时刻只能有一个线程执行，因为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.)
结论：在Cpython解释器中，同一个进程下开启的多线程，同一时刻只能有一个线程执行，无法利用多多核优势。
GIL全局解释器的优缺点：
优点：
保证数据的安全
缺点：
单个进程下，开启多个线程，牺牲执行效率，无法实现并行，只能实现并发
- IO密集型：用多线程
- 计算密集型：用多进程
'''
import time
from threading import Thread, Lock
lock = Lock()
n = 100
def task():
lock.acquire()
global n
m = n
time.sleep(1)
n = m - 1
lock.release()
if __name__ == '__main__':
list1 = []
for line in range(10):
t = Thread(target=task)
t.start()
list1.append(t)
for t in list1:
t.join()
print(n)
# 查文档，看是否能手动清理内存
# import gc
# - 查看课外问题:
# - 国内: 开源中国、CSDN、cnblogs、https://www.v2ex.com/
# - 国外: Stack Overflow、github、谷歌
二、使用多线程提高效率
from threading import Thread
from multiprocessing import Process
import time
'''
IO密集型下使用多线程
计算密集型下使用多进程
IO密集型任务，每个任务4s
- 单核：
- 开启多线程节省资源
- 多核：
- 多线程：
- 开启4个子线程：16s
- 多进程：
- 开启4个子进程：16s + 申请开启资源消耗的时间
计算密集型任务，每个任务4s
- 单核：
- 开启线程比进程节省资源
- 多核：
多线程：
- 开启4个子线程：16s
多进程：
- 开启多个进程：4s
'''
# def task1():
# #计算1000000词的 += 1
# i = 10
# for line in range(1000000):
# i += 1
#
#
# def task2():
# time.sleep(2)
#
#
# if __name__ == '__main__':
#
# # 1、开启多进程
# # 测试计算密集型
# start_time = time.time()
# list1 = []
# for line in range(6):
# p = Process(target=task1)
# p.start()
# list1.append(p)
#
# for p in list1:
# p.join()
#
# end_time = time.time()
#
# #消耗时间
# print(f'多进程计算密集型消耗时间：{end_time - start_time}')
# #多进程密集型消耗时间：1.4906916618347168
#
# # 测试IO密集型
# start_time = time.time()
# list1 = []
# for line in range(6):
# p = Process(target=task2)
# p.start()
# list1.append(p)
#
# for p in list1:
# p.join()
#
# end_time = time.time()
#
# #消耗时间
# print(f'多进程IO型消耗时间：{end_time - start_time}')
#
#
#
#
# #2、开启多线程
# #测试计算密集型
# start_time = time.time()
# list1 = []
# for line in range(6):
# t = Thread(target=task1)
# t.start()
# list1.append(t)
#
# for t in list1:
# t.join()
#
# end_time = time.time()
# print(f'多线程计算密集型消耗时间：{end_time - start_time}')
# #多线程密集型消耗时间：0.41376233100891113
#
#
# #测试IO密集型
# start_time = time.time()
# list1 = []
# for line in range(6):
# t = Thread(target=task2)
# t.start()
# list1.append(t)
#
# for t in list1:
# t.join()
#
# end_time = time.time()
# print(f'多线程IO密集型消耗时间：{end_time - start_time}')
#
# 计算密集型任务
def task1():
# 计算1000000次 += 1
i = 10
for line in range(10000000):
i += 1
# IO密集型任务
def task2():
time.sleep(3)
if __name__ == '__main__':
# 1、测试多进程:
# 测试计算密集型
start_time = time.time()
list1 = []
for line in range(6):
p = Process(target=task1)
p.start()
list1.append(p)
for p in list1:
p.join()
end_time = time.time()
# 消耗时间: 5.33872389793396
print(f'计算密集型消耗时间: {end_time - start_time}')
# 测试IO密集型
start_time = time.time()
list1 = []
for line in range(6):
p = Process(target=task2)
p.start()
list1.append(p)
for p in list1:
p.join()
end_time = time.time()
# 消耗时间: 4.517091751098633
print(f'IO密集型消耗时间: {end_time - start_time}')
# 2、测试多线程:
# 测试计算密集型
start_time = time.time()
list1 = []
for line in range(6):
p = Thread(target=task1)
p.start()
list1.append(p)
for p in list1:
p.join()
end_time = time.time()
# 消耗时间: 5.988943815231323
print(f'计算密集型消耗时间: {end_time - start_time}')
# 测试IO密集型
start_time = time.time()
list1 = []
for line in range(6):
p = Thread(target=task2)
p.start()
list1.append(p)
for p in list1:
p.join()
end_time = time.time()
# 消耗时间: 3.00256085395813
print(f'IO密集型消耗: {end_time - start_time}')
结论：
# 由1和3对比得：在计算密集型情况下使用多进程（多核的情况下多个CPU）
# 由2和3对比得：在IO密集型情况下使用多线程（多核的情况下多个CPU）
# 都使用多线程（单核单个CPU）
三、协程
'''
1、什么是协程？
- 进程：资源单位
- 线程：执行单位
- 协程：单线程下实现并发
- 在IO密集型的情况下，使用协程能提高最高效率
注意；协程不是任何单位，只是一个程序员YY出来的东西
总结：多进程---> 多线程---> 让每一个线程都实现协程（单线程下实现并发）
协程的目的：
- 手动实现“遇到IO切换 + 保存状态” 去欺骗操作系统，让操作系统误以为没有IO操作，将CPU的执行权限给你
'''
import time
def task1():
time.sleep(1)
def task2():
time.sleep(3)
def task3():
time.sleep(5)
def task4():
time.sleep(7)
def task5():
time.sleep(9)
#遇到IO切换（gevent） + 保存状态
from gevent import monkey #猴子补丁
monkey.patch_all() #监听所有的任务是否有IO操作
from gevent import spawn #spawn(任务)
from gevent import joinall
import time
def task1():
print('start from task1....')
time.sleep(1)
print('end from task1....')
def task2():
print('start from task2....')
time.sleep(1)
print('end from task2....')
def task3():
print('start from task3....')
time.sleep(1)
print('end from task3....')
if __name__ == '__main__':
start_time = time.time()
sp1 = spawn(task1)
sp2 = spawn(task2)
sp3 = spawn(task3)
# sp1.start()
# sp2.start()
# sp3.start()
# sp1.join()
# sp2.join()
# sp3.join()
joinall([sp1, sp2, sp3]) #等同于上面六步
end_time = time.time()
print(f'消耗时间:{end_time - start_time}')
# start from task1....
# start from task2....
# start from task3....
# end from task1....
# end from task2....
# end from task3....
# 消耗时间:1.0085582733154297
### 四、tcp服务端实现并发
- 代码
```python
- client 文件
import socket
client = socket.socket()
client.connect(
('127.0.0.1', 9000)
)
print('Client is run....')
while True:
msg = input('客户端>>:').encode('utf-8')
client.send(msg)
data = client.recv(1024)
print(data)
- sever 文件
import socket
from concurrent.futures import ThreadPoolExecutor
server = socket.socket()
server.bind(
('127.0.0.1', 9000)
)
server.listen(5)
# 1.封装成一个函数
def run(conn):
while True:
try:
data = conn.recv(1024)
if len(data) == 0:
break
print(data.decode('utf-8'))
conn.send('111'.encode('utf-8'))
except Exception as e:
break
conn.close()
if __name__ == '__main__':
print('Server is run....')
pool = ThreadPoolExecutor(50)
while True:
conn, addr = server.accept()
print(addr)
pool.submit(run, conn)