全局解释器和线程

Posted 2021-03-23 bs2019

目录

• 1.全局解释器锁
  • 2.协程
  • 3.使用多线程提高效率

1.全局解释器锁

1.1python解释器：

? -Cpython c语言

? -Jpython java

1.2GIL :全局解释器

? -翻译：在同一个进程下开启的多线程，同一时刻只能有有一个线程执行，因为cpython的内存管理不是线程安全。

? -GIL全局解释器，本质上是一把互斥锁，保证数据安全

? 在Cpython解释器中，同一个进程下开启多个线程，同一时刻只能有一个线程执行，无法利用多核优势。

? -为什么要有全局解释器锁：

? -没有锁

? -GIL全局解释器锁的优点：

? -优点：

? 保证数据的安全

? -缺点：

? 单个进程下，开启多个线程，牺牲执行效率了，无法实现并行，只能实现并发。

? -IO密集型： 多线程

? -计算机密集型：多进程

import time
from threading import Thread
n = 100
def task():
    global n
    m = n
    time.sleep(3)
    n =m -1####实际产生了10个99  最后一个只打印了一个n
    
    #print(n)

if __name__ == '__main__':
    list = []
    for line in range(10):
        t = Thread(target = task)
        t.start()
        list.append(t)

    for t in list:
        t.join()
    print(n)
    >>>>>>>>>>>>>>>>>>>>>>
    99

2.协程

-定义：

? -进程：资源单位

? -线程：执行单位

? -协程：单线程西实现并发

? -在IO密集的情况下，使用协程能提高最高效率

注意：协程不是任何单位，使用协程能提高最高效率

协程的目的:

? -手动实现“遇到IO切换+保存状态” ,因为是在单线程下，控制单线程的多个任务在一个任务遇到io，就切换到另外一个任务执行，这样保证了，线程能够最大限度的处于就绪化，即随时都可以被cpu执行的状态，可以去欺骗操作系统，让操作系统误以为没有io操作，从而将cpu的执行权限交给你。

? -必须只有单线程实现并发，

? -协程指的是单个线程，一旦线程出现阻塞，及那个会阻塞整个线程

from gevent import monkey  # 猴子补丁   
monkey.patch_all()  # 监听所有的任务是否有IO操作 
#上面的2个必须写在文件的开头，在time socket的模块之前，这样形成的io 可以直接识别
from gevent import spawn  # spawn(任务)  spawn(函数名，参数，参数）
from gevent import joinall
import time

def task1():
    print('start from task1...')
    time.sleep(1)
    print('end from task1...')

def task2():
    print('start from task2...')
    time.sleep(3)
    print('end from task2...')

def task3():
    print('start from task3...')
    time.sleep(5)
    print('end from task3...')


if __name__ == '__main__':

    start_time = time.time()
    sp1 = spawn(task1)
    sp2 = spawn(task2)
    sp3 = spawn(task3)
    # sp1.start()
    # sp2.start()
    # sp3.start()
    # sp1.join()
    # sp2.join()
    # sp3.join()
    joinall([sp1, sp2, sp3])

    end_time = time.time()

    print(f'消耗时间: {end_time - start_time}')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
start task1...
start task2...
start task3...
end task1...
end task2...
end task3...
消耗时间：3.0044186115264893

3.使用多线程提高效率

from threading import Thread
from multiprocessing import Process
import time

#计算密集型任务
def task1():
    i = 10
    for line in range(1000000):
        i += 1

#io密集型任务
def task2():
    time.sleep(3)

if __name__ == '__main__':
    #测试多进程
    #计算密集型
    a = time.time()
    list1 = []
    for line in range(6):
        p = Process(target = task1)
        print(p)
        p.start()
        list1.append(p)

    for p in list1:
        p.join()
    b = time.time()
    print(f'计算进程密集型消耗的时间：{b-a}')

    #测试IO密集型
    a = time.time()
    list2 = []
    for line in range(6):
        p = Process(target = task2)
        p.start()
        list2.append(p)

    for p in list2:
        p.join()
    b = time.time()
    print(f'IO进程密集型消耗时间：{b-a}')

    #2.测试多线程的
    #测试计算密集型
    a = time.time()
    list1 = []
    for line in range(6):
        p = Thread(target = task1)
        p.start()
        list1.append(p)

    for p in list1:
        p.join()
        b = time.time()
    print(f'计算线程密集型消耗时间：{b -a}')

    #测试IO密集型
    a = time.time()
    list1 = []
    for line in range(6):
        p = Thread(target = task2)
        p.start()
        list1.append(p)

    for p in list1:
        p.join()
    b = time.time()
    print(f'IO线程密集型的消耗时间：{b - a}')
    >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
计算进程密集型消耗的时间：0.3511178493499756
IO进程密集型消耗时间：3.215735912322998
计算线程密集型消耗时间：0.43486547470092773
IO线程密集型的消耗时间：3.003101110458374