并发编程： GIL锁、GIL与互斥锁区别、进程池与线程池的区别

时间：2021-11-03 07:56:19

本文目录：

一、GIL

二、关于GIL性能的讨论

三、计算密集测试

四、IO密集测试

五、GIL与互斥锁

六、进程池

七、进程什么时候算是空闲

八、线程池

一、GIL

什么叫GIL

全局解释器锁（GIL Global Interpreter Lock），锁就是线程里面那个锁，锁是为了避免资源竞争造成数据的错乱，python程序的执行过程，1.启动解释器进程  python.exe，
2.解析你的py文件并执行它，每个py程序中都必须有解释器参与解释器其实就是一堆代码，相当于多个线程要调用同一个解释器代码，共享以为竞争 ，竞争就要出事，所以给解释器加锁。
python 中内存管理依赖于 GC(一段用于回收内存的代码) 也需要一个线程

除了你自己开的线程 系统还有一些内置线程   就算你的代码不会去竞争解释器  内置线程也可能会竞争

所以必须加上锁

当一个线程遇到了IO 同时解释器也会自动解锁  去执行其他线程  CPU会切换到其他程序

x = obj  +1

a = obj  +1   2

x = None -1

a = None -1  0

二、关于GIL性能的讨论

"""

    解释器加锁以后

        将导致所有线程只能并发 不能达到真正的并行  意味着同一时间只有一个CPU在处理你的线程

        给你的感觉是效率低

    代码执行有两种状态

    阻塞 i/o 失去CPU的执行权   (CPU等待IO完成)

    非阻塞  代码正常执行 比如循环一千万次  中途CPU可能切换 很快会回来   (CPU在计算)

    假如有32核CPU 要处理一个下载任务  网络速度慢 100k/s  文件大小为1024kb

    如果你的代码中IO操作非常多  cpu性能不能直接决定你的任务处理速度

    案例:

        目前有三个任务 每个任务处理需一秒   获取元数据需要一小时

        3个CPU 需要 一小时1秒

        1个cpu 需要 一小时3秒

    在IO密集的程序中 CPU性能无法直接决定程序的执行速度    python就应该干这种活儿

    在计算密集的程序中  CPU性能可以直接决定程序的执行速度

"""

三、计算密集测试

from threading import Thread

from multiprocessing import Process

import time

# 计算密集任务

def task1():

    sum = 1

    for i in range(10000000):

        sum *= i

def task2():

    sum = 1

    for i in range(10000000):

        sum *= i

def task3():

    sum = 1

    for i in range(10000000):

        sum *= i

def task4():

    sum = 1

    for i in range(10000000):

        sum *= i

def task5():

    sum = 1

    for i in range(10000000):

        sum *= i

def task6():

    sum = 1

    for i in range(10000000):

        sum *= i

if __name__ == '__main__':

    # 开始时间

    st_time = time.time()

    # 多线程情况下

    # t1 =  Thread(target=task1)

    # t2 = Thread(target=task2)

    # t3 = Thread(target=task3)

    # t4 = Thread(target=task4)

    # t5 = Thread(target=task5)

    # t6 = Thread(target=task6)

    t1 = Process(target=task1)

    t2 = Process(target=task2)

    t3 = Process(target=task3)

    t4 = Process(target=task4)

    t5 = Process(target=task5)

    t6 = Process(target=task6)

    t1.start()

    t2.start()

    t3.start()

    t4.start()

    t5.start()

    t6.start()

    #

    # t1.join()

    # t2.join()

    # t3.join()

    # t4.join()

    # t5.join()

    # t6.join()

    print(time.time() - st_time)

四、IO密集测试

from threading import Thread

from multiprocessing import Process

import time

# 计算密集任务

def task1():

    time.sleep(3)

def task2():

    time.sleep(3)

def task3():

    time.sleep(3)

def task4():

    time.sleep(3)

def task5():

    time.sleep(3)

def task6():

    time.sleep(3)

if __name__ == '__main__':

    # 开始时间

    st_time = time.time()

    # 多线程情况下

    # t1 = Thread(target=task1)

    # t2 = Thread(target=task2)

    # t3 = Thread(target=task3)

    # t4 = Thread(target=task4)

    # t5 = Thread(target=task5)

    # t6 = Thread(target=task6)

    t1 = Process(target=task1)

    t2 = Process(target=task2)

    t3 = Process(target=task3)

    t4 = Process(target=task4)

    t5 = Process(target=task5)

    t6 = Process(target=task6)

    t1.start()

    t2.start()

    t3.start()

    t4.start()

    t5.start()

    t6.start()

    # t1.join()

    # t2.join()

    # t3.join()

    # t4.join()

    # t5.join()

    # t6.join()

    print(time.time() - st_time)

五、GIL与互斥锁

from  threading import Thread,Lock

import time

mutex = Lock()

num = 1

def task():

    global num

    # print(num)

    mutex.acquire()

    temp = num

    print(temp)

    time.sleep(1)   # 当你们线程中出现io时 GIL锁就解开

    num = temp + 1

    mutex.release()  # 线程任务结束时GIL锁解开

t1 = Thread(target=task,)

t2 = Thread(target=task,)

t1.start()

t2.start()

t1.join()

t2.join()

print(num)

#

# GIL 和 自定义互斥锁的区别

# 全局锁不能保证自己开启的线程安全  但是保证解释器中的数据的安全的

# GIL 在线程调用解释器时 自动加锁  在IO阻塞时或线程代码执行完毕时 自动解锁

#

六、进程池

"""

    进程池

        就是一个装进程的容器

    为什么出现

        当进程很多的时候方便管理进程

    什么时候用?

        当并发量特别大的时候  列入双十一

        很多时候进程是空闲的 就让他进入进程池  让有任务处理时才从进程池取出来使用

    进程池使用

        ProcessPoolExecutor类

        创建时指定最大进程数 自动创建进程

        调用submit函数将任务提交到进程池中

        创建进程是在调用submit后发生的

    总结一下:

        进程池可以自动创建进程

        进程限制最大进程数

        自动选择一个空闲的进程帮你处理任务

        遗留问题 进程什么时候算是空闲

"""

import socket

from multiprocessing import Process

from concurrent.futures import ProcessPoolExecutor

# 收发数据

def task(c, addr):

    while True:

        try:

            data = c.recv(1024)

            print(data.decode("utf-8"))

            if not data:

                c.close()

                break

            c.send(data.upper())

        except Exception:

            print("连接断开")

            c.close()

            break

if __name__ == '__main__':

    server = socket.socket()

    server.bind(("127.0.0.1",65535))

    server.listen(5)

    # 创建一个进程池   默认为CPU个数

    pool = ProcessPoolExecutor()

    while True:

        c,addr = server.accept()

        # p = Process(target=task,args=(c,addr))

        # p.start()

        pool.submit(task,c,addr)

七、进程什么时候算是空闲

from concurrent.futures import  ProcessPoolExecutor

import os,time,random

def task():

    time.sleep(random.randint(1,2))

    print(os.getpid())

def run():

    pool = ProcessPoolExecutor(2)

    for i in range(30):

        pool.submit(task)

if __name__ == '__main__':

    run()

八、线程池

from concurrent.futures import  ProcessPoolExecutor,ThreadPoolExecutor

from threading import  current_thread

import os,time,random

def task():

    time.sleep(random.randint(1,2))

    print(current_thread())

def run():

    # 默认为cpu核心数 * 5

    pool = ThreadPoolExecutor(3)

    for i in range(30):

        pool.submit(task)

if __name__ == '__main__':

    run()

相关文章