官方解释:

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.

在一个python的进程内,不仅有test.py的主线程或者由该主线程开发的其他线程,还有解释器开启的来及回收等解释器级别的线程,总之,所有线程都运行在这一个进程内.

所有线程的任务,都需要将代码传给解释器去执行,所以首先要解决的是能够访问到解释器代码

如果多个线程的target = work name执行流程是:

多个线程先访问到解释器的代码,即拿到执行权限,然后将target的代码交给解释器的代码执行,解释器的代码是所有线程共享的,所以来及回收线程也可能访问到解释器的代码而去执行,
这就导致了一个问题:对于共一个数据 100,在线程1执行x = 100的同时,垃圾回收机制执行的是回收100的操作,所以需要通过添加GIL锁,保证python解释器同一时间只能执行一个任务代码

例:

1.四个计算密集型任务, 每个10s

单核情况:

开线程更省资源

多核情况:

开进程 10s

开线程 40s

2.四个IO密集型任务, 每个10s

单核情况:

开线程更省资源

多核情况:

开线程更省资源

from multiprocessing import Process

from threading import Thread

import time, os

​

# 计算密集型

def func():

    res = 0

    for i in range(10000):

        res *= 1

​

# IO 密集型

def func():

    time.sleep(3)

​

if __name__ == '__main__':

    print(os.cpu_count())

    list = []

    start = time.time()

    for i in range(4):

        p = Process(target=func) # 多进程

        # 计算密集型运行时间:0.21994638442993164

        # IO密集型运行时间:3.2253575325012207

        p = Thread(target=func) # 多线程

        # 运行时间:0.003988504409790039

        # IO密集型运行时间:3.0033791065216064

        list.append(p)

        p.start()

    for p in list:

        p.join()  # 等待所有子进程/子线程运行结束后再运行主进程/主线程

    end = time.time()

    print('运行时间:%s'%(end - start))

​

from threading import Thread, Semaphore

import time

import random

​

sem = Semaphore(5)  # 生成一把锁五把钥匙

​

def func(name):

    sem.acquire()

    print('%s进门了'%name)

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

    sem.release()

    print('%s出门了'%name)

​

for i in range(10):

    t = Thread(target=func, args=(i, ))

    t.start()

e.set() 发信号

e.wait() 等待信号

from threading import Thread, Event

import time

​

​

e = Event()

def light():

    print('红灯')

    time.sleep(3)

    e.set()

    print('绿灯')

​

def car(name):

    print('%s等红灯'%name)

    e.wait()

    print('%s开车了'%name)

​

t = Thread(target=light)

t.start()

​

for i in range(10):

    t = Thread(target=car, args=('车手%i'%i, ))

    t.start()

import queue

​

q = queue.Queue()

q.put('one')

q.put('two')

q.put('three')

print(q.get())  # >>> one  先进先出

​

q = queue.LifoQueue()

q.put('one')

q.put('two')

q.put('three')

print(q.get())  # >>> three  堆栈 先进后出

​

q = queue.PriorityQueue()  # 数字越小,优先级越高

q.put((10, 'one'))

q.put((1, 'two'))

q.put((5, 'three'))

print(q.get())  # >>> (1, 'two')