并发编程(下)

多进程实现TCP服务端并发

# 导入socket
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())

# 判断是否为执行文件，主要作为兼容win
if __name__ == '__main__':
    # 获取服务端信息
    server = get_server()
    # 循环开设进程
    while True:
        # 用于接收客户端请求
        sock, addr = server.accept()
        # 开设进程聊天
        p = Process(target=get_talk, args=(sock,))
        # 启动进程
        p.start()

互斥锁代码实操

互斥锁: 对共享数据进行锁定，保证同一时刻只能有一个线程去操作
互斥锁是多个线程一起去抢，抢到锁的线程先执行，没有抢到锁的线程需要等待，等互斥锁使用完释放后，其它等待的线程再去抢这个锁。所以互斥锁也是独占锁
互斥锁🔐：建议只对操作数据的部分加锁，否则整个程序效率会极低，并且使用不当较为造成死锁，相关死锁在接下来也会介绍

# 互斥锁代码实际操作
from multiprocessing import Process, set_start_method, Lock  # 可以在multiprocessing这个模块中直接引用Lock
import time
import json
import random

# 用户查看票
def search(name):
    with open(r'/Users/wesley/PycharmProjects/pythonProject5/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'/Users/wesley/PycharmProjects/pythonProject5/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'/Users/wesley/PycharmProjects/pythonProject5/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()  # 释放锁

set_start_method('fork')
if __name__ == '__main__':
    # 需要在这里产生一把锁
    mutex = Lock()

    for i in range(10):
        p = Process(target=run, args=('用户%s号' % i, mutex))
        p.start()

线程理论

线程是程序中最小执行单位，每一个进程中至少有一个线程
进程时资源单位，一般代表一块内存空间
线程才是执行单位，是真正的代码指令

一个进程内可以开设多个线程
同一个进程下的多个线程的数据是共享的
创建进程的消耗要远远大于创建线程
// 待补充

创建线程的多种方式

第一种方式
# 创建线程需要使用threading模块
import time
from threading import Thread

def task(name):
    print(f'{name} is running')
    time.sleep(0.1)
    print(f'{name} is over')

if __name__ == '__main__':
    for i in range(1000):
        t = Thread(target=task, args=('用户%s' %i,))
        t.start()


第二种方式
import time
from threading import Thread
class MyThread(Thread):
    def run(self) -> None:
        print('run is runing')
        time.sleep(1)
        print('run is over')

obj = MyThread()
obj.start()
print('主进程')

线程的诸多特性

1.join方法
2.同进程内多个线程数据共享
3.current_thread()
4.active_count()
待补充

守护线程
同进程
线程诸多方法
同进程
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解释器中内存管理不是线程安全的(垃圾回收机制)

验证GIL的存在


# 验证GIL存在

from threading import Thread

num = 100

def task():
    global num
    num -= 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(num)

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)

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
"""

死锁现象

死锁现象非常的有意思，比如说我们面试的时候面试官需要让我们解释死锁
面试官：请你解释一下什么是死锁
候选人：让我进公司就告诉你
面试官：那你先解释什么是死锁
候选人：那你先让我进公司我告诉你啊
以上依次往复，这就是死锁

# 代码实现死锁现象
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()

信号量

信号量需要使用Semaphore，同样在threading模块下

from threading import Thread, Lock, Semaphore
import time
import randon

sp = Semaphore(5)  # 一次性产生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线程执行到 event.set()位置后并且自己有event.wait()后才能继续向下执行
使用的是threading下的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()

进程池与线程池

进程和线程能否无限制的创建 不可以
因为硬件的发展赶不上软件 有物理极限 如果我们在编写代码的过程中无限制的创建进程或者线程可能会导致计算机奔溃

池
	降低程序的执行效率 但是保证了计算机硬件的安全
进程池
	提前创建好固定数量的进程供后续程序的调用 超出则等待
线程池
	提前创建好固定数量的线程供后续程序的调用 超出则等待
 
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)

协程

协程需要使用猴子模块
threading模块通过应用线程实现并发，multiprocessing使用进程实现并发。在python中，还有另外一种实现并发的方式，那就是协程一种单线程单进程的方法来实现并发

"""
进程:资源单位
线程:执行单位
协程:单线程下实现并发(效率极高)
	在代码层面欺骗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()

如何不断的提升程序的运行效率
	多进程下开多线程 多线程下开协程

posted @ 2025-03-13 13:51 樵夫- 阅读(6) 评论(0) 收藏举报

刷新页面返回顶部

樵夫的博客

赶山的樵夫

并发编程(下)

公告