11.21
今日内容
1.多进程实现TCP服务端并发
2.互斥锁代码实操
3.线程理论
4.创建线程的两种方式
5.线程的诸多特性
6.GIL全局解释器锁
7.GIL与普通互斥锁
8.python多线程是否有用
9.死锁现象
10.信号量
11.event事件
12.进程池与线程池
13.协程
1.多进程实现TCP服务端并发
服务端
import socket
from multiprocessing import Process
def get_server():
server = socket.socket()
server.bind(('127.0.0.1', 8080))
server.listen(5)
return server
def get_talk(sock):
while True:
data = sock.recv(1024)
print(data.decode('utf8'))
sock.send(data.upper())
if __name__ == '__main__':
server = get_server()
while True:
sock, addr = server.accept()
开设多进程去聊天
p = Process(target=get_talk, args=(sock,))
p.start()
2.互斥锁代码实操
锁:建议只加载操作数据的部分 否则整个程序的效率会极低
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:
with open(r'data.json', 'w', encoding='utf8') as f:
data['ticket_num'] -= 1
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__':
mutex = Lock() # 产生一把锁
for i in range(10):
p = Process(target=run, args=('用户%s号' % i, mutex))
p.start()
锁有很多种,但是作用都一样
3.线程理论
进程:进程其实是资源单位,表示一块内存空间
线程:线程才是执行单位,表示真正的代码指令
我们可以将进程比喻是车间,线程是车间里面的流水线
一个进程内部至少含有一个线程
1.一个进程内可以开设多个线程
2.同一个进程下的多个线程数据是共享的
3.创建进程与线程的区别:创建进程的消耗要远远大于线程
4.创建线程的两种方式
from threading import Thread
from multiprocessing import Process
import time
def task(name):
print(f'{name} is running')
time.sleep(0.1)
print(f'{name} is over')
if __name__ == '__main__':
start_time = time.time()
p_list = []
for i in range(100):
p = Process(target=task, args=('用户%s'%i,))
p.start()
p_list.append(p)
for p in p_list:
p.join()
print(time.time() - start_time)
t_list = []
for i in range(100):
t = Thread(target=task, args=('用户%s'%i,))
t.start()
t_list.append(t)
for t in t_list:
t.join()
print(time.time() - start_time)
t = Thread(target=task, args=('jason',))
t.start()
print('主线程')
创建线程无需考虑反复执行的问题
class MyThread(Thread):
def run(self):
print('run is running')
time.sleep(1)
print('run is over')
obj = MyThread()
obj.start()
print('主线程')
5.线程的诸多特性
1.join方法
2.同进程内多个线程数据共享
3.current_thread()
4.active_count()
6.GIL全局解释器锁
官方文档对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.在CPython解释器中存在全局解释器锁简称GIL
python解释器有很多类型,常用的是CPython解释器
CPython JPython PyPython
2.GIL本质也是一把互斥锁,用来阻止同一个进程内多个线程同时执行(重要)
3.GIL的存在是因为CPython解释器中内存管理不是线程安全的(垃圾回收机制)
垃圾回收机制:引用计数、标记清除、分代回收
7.GIL与普通互斥锁
GIL只能够确保同进程内多线程数据不会被垃圾回收机制弄乱 ,并不能确保程序里面的数据是否安全
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()
print(num)
8.python多线程是否有用
需要分情况
1.单个CPU
IO密集型 多线程有优势
多进程:申请额外的空间,消耗更多的资源
多线程:消耗资源相对较少,通过多道技术
计算密集型 多线程有优势
多进程:申请额外的空间,消耗更多的资源(总耗时+申请空间+拷贝代码+切换)
多线程:消耗资源相对较少,通过多道技术(总耗时+切换)
2.多个CPU
IO密集型 多线程有优势
多进程:总耗时(单个进程的耗时+IO+申请空间+拷贝代码)
多线程:总耗时(单个进程的耗时+IO)
计算密集型 多进程完胜
多进程:总耗时(单个进程的耗时)
多线程:总耗时(多个进程的综合)
9.死锁现象
acquire()
release()
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):
obj = MyThread()
obj.start()
10.信号量
在python并发编程中信号量相当于多把互斥锁(公共厕所)
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()
11.event事件
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()
12.进程池与线程池
进程和线程不可以无限制的创建,因为硬件的发展赶不上软件,有物理极限,如果我们在编写代码的过程中无限制的创建进程或者线程可能会导致计算机奔溃
池:降低程序的执行效率,但是保证了计算机硬件的安全,安全很重要
进程池：提前创建好固定数量的进程供后续程序的调用，超出则等待
线程池：提前创建好固定数量的线程供后续程序的调用，超出则等待
from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
import os
import time
import random
from threading import current_thread
1.产生含有固定数量线程的线程池
pool = ThreadPoolExecutor(10)
pool = ProcessPoolExecutor(5)
def task(n):
print('task is running')
time.sleep(random.randint(1, 3))
print('task is over', n, current_thread().name)
print('task is over', os.getpid())
return '我是task函数的返回值'
def func(*args, **kwargs):
print('from func')
if __name__ == '__main__':
2.将任务提交给线程池即可
for i in range(20):
res = pool.submit(task, 123) # 朝线程池提交任务
print(res.result()) # 不能直接获取
pool.submit(task, 123).add_done_callback(func)
13.协程
进程:资源单位
线程:执行单位
协程:单线程下实现并发(效率极高)
在代码层面欺骗CPU,让CPU觉得我们的代码里面没有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('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
协程实现并发
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号