并发编程四

怼怼哎

已于 2022-08-29 21:48:15 修改

阅读量110

点赞数

文章标签： python

于 2022-08-11 22:43:04 首次发布

本文链接：https://blog.csdn.net/m0_72611192/article/details/126291777

版权

GIL全局解释器锁

储备知识

1.python解释器也是由编程语言写出来的
	Cpython  用C写出来的
	Jpython  用Java写出来的
	Pypython 用python写出来的

ps:最常用的就是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.)

“”"

1.GIL的研究是Cpython解释器的特点不是python语言的特点

2.GIL本质也是一把互斥锁

3.GIL的存在使得同一个进程下的多个线程无法同时执行(关键) 言外之意:单进程下的多线程无法利用多核优势效率低!!!

4.GIL的存在主要是因为cpython解释器中垃圾回收机制不是线程安全的

在这里插入图片描述

“”"
1.误解:python的多线程就是垃圾利用不到多核优势 python的多线程确实无法使用多核优势但是在IO密集型的任务下是有用的
2.误解:既然有GIL 那么以后我们写代码都不需要加互斥锁不对 GIL只确保解释器层面数据不会错乱(垃圾回收机制) 针对程序中自己的数据应该自己加锁处理
3.所有的解释型编程语言都没办法做到同一个进程下多个线程同时执行
“”"

验证GIL的存在

from threading import Thread

money = 888


def task():
    global money
    money -= 1


for i in range(888):
    t = Thread(target=task)
    t.start()
# 等待所有线程结束后查看money是多少
print(money)  # 0


money = 888


def task():
    global money
    money -= 1

t_list = []
for i in range(888):
    t = Thread(target=task)
    t.start()
    t_list.append(t)

for t in t_list:
    t.join()
# 等待所有线程结束后查看money是多少
print(money)  # 0

验证GIL的特点

from threading import Thread
import time


money = 888


def task():
    global money
    tmp = money
    time.sleep(0.2)
    money = tmp-1

t_list = []
for i in range(888):
    t = Thread(target=task)
    t.start()
    t_list.append(t)

for t in t_list:
    t.join()
# 等待所有线程结束后查看money是多少
print(money)  # 887

GIL不会影响程序层面的数据也不会保证它的修改是安全的要想保证得自己加锁

from threading import Thread, Lock
import time


money = 888
mutex = Lock()

def task():
    mutex. acquire()
    global money
    tmp = money
    time.sleep(0.01)
    money = tmp-1
    mutex.release()

t_list = []
for i in range(888):
    t = Thread(target=task)
    t.start()
    t_list.append(t)

for t in t_list:
    t.join()
# 等待所有线程结束后查看money是多少
print(money)  # 0

验证python多线程是否有用

情况1：

    单个CPU
    多个CPU

情况2：

     IO密集型（代码有IO操作）
     计算密集型（代码没有IO操作）

单个CPU&IO密集型：

     多进程
              申请额外的空间，消耗更多的资源
      多线程
               消耗资源相对较少，通过多道技术
            多线程优势

单个CPU&计算密集型;

        多进程
              申请额外的空间，消耗更多的资源(总耗时+申请空间+拷贝代码+切换）
         多线程
               消耗资源相对较少，通过多道技术（总耗时+切换）
         多线程有优势

多个CPU&IO密集型：

         多进程
             总耗时（单个进程+IO+申请空间+拷贝代码）
      多线程
              总耗时（单个进程+IO）
         多线程优势

多个CPU&计算密集型

      多进程
             总耗时（单个进程）
      多线程
              总耗时（多喝进程的综合）  
              多进程优势

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):
    t = MyThread()
    t.start()

信号量

信号量本质也是互斥锁只不过它是多把锁
“”"
强调:
信号量在不同的知识体系中意思可能有区别
在并发编程中信号量就是多把互斥锁
在django中信号量指的是达到某个条件自动触发(中间件)
…
“”"
‘’’
我们之前使用Lock产生的是单把锁
类似于单间厕所
信号量相当于一次性创建多间厕所
类似于公共厕所
‘’’

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事件

子进程\子线程之间可以彼此等待彼此
eg:
子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()

通过event事件来控制红绿灯通行车辆

事件的初始值为False，所以最开始就是红灯，先模拟红绿灯的规律，设定为每两秒变换一次灯，然后再模拟车辆通行，通过事件来将两者的事件结合起来，
当事件为False时，为红灯，车辆处于等待状态，一直wait，但是当事件为True时，变为绿灯，阻塞状态取消，车辆为通行状态。在此文件中，设定车辆通行完成
则执行结束，故管理车辆通行的函数设定为join，红绿灯函数随着主进程的结束而结束，故设定为守护进程。

import time

from multiprocessing import Event,Process

def traffic(e):
    print("33[31;1m红灯33[0m")
    while 1:
        if e.is_set():
            time.sleep(2)
            print("33[31;1m红灯33[0m")
            e.clear()

        else:
            time.sleep(2)
            print("33[32;1m绿灯33[0m")
            e.set()

def car(e,i):
    if not e.is_set():
        print("%s 正在等车..." %i)
        e.wait()
    print("%s 通过" %i)

if __name__ == '__main__':
    e = Event()
    c_l = []
    p = Process(target=traffic, args=(e,))
    p.daemon = True
    p.start()
    for i in range(20):
        time.sleep(random.randint(0,2)) #模拟随机车辆通行
        c = Process(target=car,args=(e,"car%s"%i))
        c.start()
        c_l.append(c)
    for c in c_l:
        c.join()

进程池和线程池

多进程多线程
开设多进程或者多线程的时候还需要考虑硬件的承受范围
池
降低程序的执行效率保证计算机硬件的安全
进程池
提前创建好固定个数的进程供程序使用后续不会再创建
线程池
提前创建好固定个数的线程供程序使用后续不会再创建

进程池和线程池的实操

from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
add_done_callback

from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
from  threading import current_thread
import time

pool = ThreadPoolExecutor(3)


def  task(n):
    print(current_thread().name)
    # print(n)
    time.sleep(1)


def func(*args,**kwargs):
    print('func',args,kwargs)

for i in range(10):
    pool.submit(task,123).add_done_callback(func)
    """异步回调:异步任务执行完成后有结果就会自动触发该机制"""

协程

进程：资源单位
线程：执行单位
协程：单线程下实现并发
在代码层面欺骗CPU 让CPU觉得我们的代码里面没有IO操作
cpu离开的两种条件：
1 遇到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服务端并发

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()