python——进程与线程及相关操作
一、多进程实现TCP服务端并发
1.server端代码
# coding:utf-8
import socket
from multiprocessing import Process
# 定义服务端信息函数(因为不封装只能执行一次，不能实现与多个客户端交互)
def get_server():
# 实例化socket对象
server = socket.socket()
# 绑定一个固定的IP地址和端口号
server.bind(('127.0.0.1', 8088))
# 半连接池，设置最大链接数量
server.listen(8)
# 返回值为server（谁调用get_server函数返回给谁）
return server
# 定以获取客户端信息的函数
def get_talk(sock):
while True:
# 接收客户端数据，括号内设置最大接收字节
date = sock.recv(1024)
# 编码并输出客户端信息
print(date.decode('utf-8'))
# 向客户端发送接收到的数据并大写
sock.send(date.upper())
# 定义主函数，创建进程只有在主函数内才可以被执行（当前文件是执行文件）
if __name__ == '__main__':
# 执行get_server函数，并且用server接收get_server函数的返回值
server = get_server()
while True:
# 等待接收客户端数据和ip地址
sock, addr = server.accept()
print(sock, addr)
# 开设多进程去聊天
p = Process(target=get_talk, args=(sock,))
# 开始启动进程
p.start()
2.client端代码
# coding:utf-8
import socket
def get_client():
# 实例化socket对象
client = socket.socket()
# 绑定服务端的ip地址和端口号
client.connect(('127.0.0.1', 8088))
return client
while True:
client = get_client()
client.send(b'hello server!')
date = client.recv(1024)
print(date.decode('utf-8'))
二、互斥锁代码实现
# coding:utf-8
from multiprocessing import Process, Lock
import time
import json
import random
# 互斥锁： 建议只加载操作数据的部分，否则整个程序的效率极低
def search(name):
with open(r'data.json', 'r', encoding='utf-8') as f:
data = json.load(f)
print('%s查看票，目前剩余票：%s' % (name, data.get('ticket_num')))
def buy(name):
# 先查询票数
with open(r'data.json', 'r', encoding='utf-8') 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='utf-8') 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()
三、线程理论
1、线程的概念
进程
进程其实是资源单位 表示一块内存空间
线程
线程才是执行单位 表示真正的代码指令
我们可以将进程比喻是车间 线程是车间里面的流水线
一个进程内部至少含有一个线程
1.一个进程内可以开设多个线程
2.同一个进程下的多个线程数据是共享的
3.创建进程与线程的区别
创建进程的消耗要远远大于线程
2、创建线程的两种方式
# coding:utf-8
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)
"""
这个是线程
"""
start_time = time.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)
class MyThread(Thread):
def run(self):
print('run is running')
time.sleep(1)
print('run is over')
obj = MyThread()
obj.start()
print('main thread')
四、GIL全局解释器锁
1、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 JPython PyPython (常用的是CPython解释器)
2.GIL本质也是一把互斥锁 用来阻止同一个进程内多个线程同时执行(重要)
3.GIL的存在是因为CPython解释器中内存管理不是线程安全的(垃圾回收机制)
垃圾回收机制
引用计数、标记清除、分代回收
"""
2、验证GIL的存在
# coding:utf-8
from threading import Thread
money = 999
def my_thread():
global money
money -= 1
t_list = []
for i in range(999):
t = Thread(target=my_thread)
t.start()
t_list.append(t)
for t in t_list:
t.join()
print(money) # 0
3、GIL与普通互斥锁
"""
GIL只能够确保同进程内多线程数据不会被垃圾回收机制弄乱
并不能确保程序里面的数据是否安全
"""
# coding:utf-8
import time
from threading import Thread, Lock
money = 100
def task(mutex):
global money
mutex.acquire()
count = money
time.sleep(0.1)
money = 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(t)
print(money)
五、python多线程是否有用
需要分情况
情况1
单个CPU
多个CPU
情况2
IO密集型(代码有IO操作)
计算密集型(代码没有IO)
1.单个CPU
IO密集型
多进程
申请额外的空间 消耗更多的资源
多线程
消耗资源相对较少 通过多道技术
ps:多线程有优势!!!
计算密集型
多进程
申请额外的空间 消耗更多的资源(总耗时+申请空间+拷贝代码+切换)
多线程
消耗资源相对较少 通过多道技术(总耗时+切换)
ps:多线程有优势!!!
2.多个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
"""
六、死锁现象
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()
七、信号量
'''
在python并发编程中信号量相当于多把互斥锁(公共厕所)
'''
# coding:utf-8
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事件
# coding:utf-8
from threading import Thread, Event
import time
event = Event()
def light():
print('red light is bu ling bu ling!')
time.sleep(3)
print('green light is bu ling bu ling!')
event.set()
def car(name):
print('%s is waiting red light!' % name)
event.wait()
print('%s go go go!' % name)
t = Thread(target=light)
t.start()
for i in range(20):
t = Thread(target=car, args=('panda PRO%s' % i,))
t.start()
九、进程池与线程池
'''
进程和线程能否无限制的创建 不可以
因为硬件的发展赶不上软件 有物理极限 如果我们在编写代码的过程中无限制的创建进程或者线程可能会导致计算机奔溃
池
降低程序的执行效率 但是保证了计算机硬件的安全
进程池
提前创建好固定数量的进程供后续程序的调用 超出则等待
线程池
提前创建好固定数量的线程供后续程序的调用 超出则等待
'''
# coding:utf-8
from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
import os
import time
import random
from threading import current_thread
# 产生含有固定数量线程的线程池
pool = ProcessPoolExecutor(5)
def task(n):
print('task is running!')
time.sleep(random.randint(1, 3))
print('task is over!', os.getpid())
return 'i\'m is task function\' return number！'
def func(*args, **kwargs):
print('from function!')
if __name__ == '__main__':
# 将任务提交给线程池即可
for i in range(20):
# 向线程池提交任务
res = pool.submit(task, 'return number')
# 不能直接获取
print(res.result())
pool.submit(task, 'return number').add_done_callback(func)
十、协程
"""
进程:资源单位
线程:执行单位
协程:单线程下实现并发(效率极高)
在代码层面欺骗CPU 让CPU觉得我们的代码里面没有IO操作
实际上IO操作被我们自己写的代码检测 一旦有 立刻让代码执行别的
(该技术完全是程序员自己弄出来的 名字也是程序员自己起的)
核心:自己写代码完成切换+保存状态
"""
# coding:utf-8
import time
from gevent import monkey, spawn
# 固定编写，用于检测所有的IO操作（猴子补丁）
monkey.patch_all()
def func1():
print('func1 running!')
time.sleep(3)
print('func1 running!')
def func2():
print('func2 running!')
time.sleep(5)
print('func2 running!')
if __name__ == '__main__':
start_time = time.time()
func1()
func2()
s1 = spawn(func1)
s2 = spawn(func2)
s1.join()
s2.join()
print(time.time() - start_time)
十一、协程实现并发
# coding:utf-8
import socket
from gevent import monkey, spawn
# 固定编写 用于检测所有的IO操作（猴子补丁）
monkey.patch_all()
def communication(sock):
while True:
data = sock.recv(1024)
print(data.decode('utf-8'))
sock.send(data.upper())
def get_server():
server = socket.socket()
server.bind(('127.0.0.1', 8088))
server.listen(8)
while True:
# IO操作
sock, addr = server.accept()
spawn(communication, sock)
s1 = spawn(get_server)
s1.join()
if __name__ == '__main__':
start_time = time.time()
func1()
func2()
s1 =
浙公网安备 33010602011771号