Python多线程详解

文章目录

  • 1. 多线程
  • 2. 创建线程
    • 2.1 直接创建
    • 2.2 继承创建
  • 3. 守护线程
  • 4. 阻塞线程
  • 5. 线程锁
    • 5.1 互斥锁(Lock)
    • 5.2 递归锁(RLock)
    • 5.3 信号量(Semaphore)
    • 5.4 事件(Event)
  • 6. ThreadLocal
  • 7. 线程池
    • 7.1 基本使用
    • 7.2 as_completed 方法
    • 7.3 wait方法
    • 7.4 map方法
  • 8. Python线程真相
  • 参考文章

1. 多线程

线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中,是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务。Python中的程序默认是只有一个主线程的,也就是说,执行程序的时候,你写的代码都是串行执行的,CPU利用率可能并没有得到很好的利用,还有很多的空闲,而这个时候利用多线程,将程序改为并行的话,CPU利用率将会大大提升,程序速度也就能大大增快。

Python处理线程的模块有两个:threadthreading。Python 3已经停用了 thread 模块,并改名为 _thread 模块。Python 3在 _thread 模块的基础上开发了更高级的 threading 模块,因此以下的讲解都是基于 threading 模块。

threading 模块除了包含 _thread 模块中的所有方法外,还提供的其他方法,常用的方法如下:

方法 描述
threading.current_thread() 返回当前线程的信息
threading.enumerate() 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前,不包括启动前和终止后的线程。
threading.active_count() 返回正在运行的线程数量,与len(threading.enumerate())有相同的结果

测试如下:

import threading


if __name__ == "__main__":
    print("当前活跃线程的数量", threading.active_count())
    print("将当前所有线程的具体信息展示出来", threading.enumerate())
    print("当前的线程的信息展示", threading.current_thread())

输出结果:

当前活跃线程的数量 1
将当前所有线程的具体信息展示出来 [<_MainThread(MainThread, started 13228)>]
当前的线程的信息展示 <_MainThread(MainThread, started 13228)>

2. 创建线程

创建线程的方法有两种,一种是直接使用 threading 模块里面的类来进行创建,一种是继承 threading 模块的类写一个类来对线程进行创建。

2.1 直接创建

我们可以通过直接从 threading.Thread 继承创建一个新的子类,并实例化后调用 start() 方法启动新线程,即相当于它调用了线程的 run() 方法。

该方法的参数如下:

threading.Thread(target=None, name=None, args=(), kwargs={})

target 指要创建的线程的方法名,name 指给此线程命名,命名后可以调用 threading.current_thread().name 方法输出该线程的名字, args/kwargstarget 指向的方法需要传递的参数,必须是元组形式,如果只有一个参数,需要以添加逗号。

假如我们创建两个线程,一个每隔两秒对传入的数加2,一个每隔1秒对传入的数加1,代码示例如下:

import threading
import time


def job1(num):
    while True:
        num += 2
        print('{} is running >> {}'.format(threading.current_thread().name, num))
        time.sleep(2)


new_job = threading.Thread(target=job1, name='Add2', args=(100,))
new_job.start()
n = 1
while True:
    n += 1
    print('{} is running >> {}'.format(threading.current_thread().name, n))
    time.sleep(1)

输出如下:

Add2 is running >> 102
MainThread is running >> 2
MainThread is running >> 3
Add2 is running >> 104
MainThread is running >> 4
MainThread is running >> 5
Add2 is running >> 106
MainThread is running >> 6
MainThread is running >> 7
Add2 is running >> 108
MainThread is running >> 8
MainThread is running >> 9
Add2 is running >> 110
……

2.2 继承创建

第二种继承的方式来创建一个线程类,继承这个类后,必须要重写其中的 run 方法,也就相当于上述的直接创建中的 start 方法。

下面我用继承类的方式实现与上面的效果一样的多线程。

import threading
import time


class MyThread(threading.Thread):
    def __init__(self, n):
        super().__init__() #必须调用父类的初始化方法
        self.n = n

    def run(self) -> None:
        while True:
            self.n += 2
            print('{} is running >> {}'.format(threading.current_thread().name, self.n))
            time.sleep(2)


new_job = MyThread(100)
new_job.setName("Add2")
new_job.start()
n = 1
while True:
    n += 1
    print('{} is running >> {}'.format(threading.current_thread().name, n))
    time.sleep(1)

输出与以上输出一致。

3. 守护线程

上面第二节中,我只设置了一个子线程,为什么会有两个线程在分别运行呢?原因就是该程序在启动时都会有一个主线程在进行运行,而我们创建的线程统统都称之为子线程,当我们创建了一个子线程时,加上主线程,就已经有两个线程了。明白了主线程与子线程后,我们再来介绍守护线程。

如果当前python线程是守护线程,那么意味着这个线程是“不重要”的,“不重要”意味着如果他的主线程结束了但该守护线程没有运行完,守护线程就会被强制结束。如果线程是非守护线程,那么父进程只有等到非守护线程运行完毕后才能结束。

  • 只要当前 主线程中尚存任何一个非守护线程没有结束,守护线程就全部工作;
  • 只有当最后一个非守护线程结束是,守护线程随着主线程一同结束工作。
  1. 设置全部子线程为守护线程

    下面我们设置两个子线程一个子线程每隔1秒加1,一个线程每隔2秒加2,两个子线程都设置为守护线程,主线程等待3秒后结束,看看输出的情况。

    import threading
    import time
    
    # 每1秒加1
    def job1(num):
        while True:
            num += 1
            print('{} is running >> {}'.format(threading.current_thread().name, num))
            time.sleep(1)
    
    # 每2秒加2
    def job2(num):
        while True:
            num += 2
            print('{} is running >> {}'.format(threading.current_thread().name, num))
            time.sleep(2)
    
    # 线程1,一秒加一
    new_job1 = threading.Thread(target=job1, name='Add1', args=(100,))
    # 设置为守护线程
    new_job1.setDaemon(True)
    new_job1.start()
    
    # 线程2,两秒加二
    new_job2 = threading.Thread(target=job2, name='Add2', args=(1,))
    new_job2.setDaemon(True)
    new_job2.start()
    
    # 主线程等待3秒
    time.sleep(3)
    print('{} Ending'.format(threading.current_thread().name))
    

    输出如下:

    Add1 is running >> 101
    Add2 is running >> 3
    Add1 is running >> 102
    Add2 is running >> 5
    Add1 is running >> 103
    MainThread Ending

    可以看到,随着输出 MainThread Ending 后,程序就运行结束了,这表明子线程全为守护线程时,会随着主线程的结束而强制结束。

  2. 一个子线程为守护线程,另一个设为非守护线程

    下面我们同样设置两个子线程一个子线程每隔1秒加1,一个线程每隔2秒加2,不同的是,一个子线程设为非守护线程,另一个子线程设为守护线程,主线程等待3秒后结束,看看输出的情况。

    import threading
    import time
    
    # 每1秒加1
    def job1(num):
        while True:
            num += 1
            print('{} is running >> {}'.format(threading.current_thread().name, num))
            time.sleep(1)
    
    # 每2秒加2
    def job2(num):
        while True:
            num += 2
            print('{} is running >> {}'.format(threading.current_thread().name, num))
            time.sleep(2)
    
    # 线程1,一秒加一
    new_job1 = threading.Thread(target=job1, name='Add1', args=(100,))
    new_job1.start()
    
    # 线程2,两秒加二
    new_job2 = threading.Thread(target=job2, name='Add2', args=(1,))
    # 设置为守护线程
    new_job2.setDaemon(True)
    new_job2.start()
    
    # 主线程等待3秒
    time.sleep(3)
    print('{} Ending'.format(threading.current_thread().name))
    

    输出结果如下:

    Add1 is running >> 101
    Add2 is running >> 3
    Add1 is running >> 102
    Add1 is running >> 103
    Add2 is running >> 5
    MainThread Ending
    Add1 is running >> 104
    Add2 is running >> 7
    Add1 is running >> 105
    Add1 is running >> 106
    Add2 is running >> 9
    Add1 is running >> 107
    Add1 is running >> 108

    可以看到,上面的主线程结束后,两个子线程并没有结束,这也表明了守护线程会等到非守护线程执行完毕后再被杀死。

需要注意的是, setDaemon 必须写在 start 方法之前。

4. 阻塞线程

join() 方法会使线程进入等待状态(阻塞),直到调用 join() 方法的子线程运行结束。同时你也可以通过设置 timeout 参数来设定等待的时间,该方法参数如下:

join([time]):

其中 time 参数可选,表示阻塞线程的秒数。

import threading
import time

# 每1秒加1
def job1(num):
    while True:
        num += 1
        print('{} is running >> {}'.format(threading.current_thread().name, num))
        time.sleep(1)

# 每2秒加2
def job2(num):
    while True:
        num += 2
        print('{} is running >> {}'.format(threading.current_thread().name, num))
        time.sleep(2)

# 线程1,一秒加一
new_job1 = threading.Thread(target=job1, name='Add1', args=(100,))
new_job1.start()

# 线程2,两秒加二
new_job2 = threading.Thread(target=job2, name='Add2', args=(1,))
# 设置为守护线程
new_job2.setDaemon(True)
new_job2.start()

# 主线程等待3秒
time.sleep(3)
print('{} Ending'.format(threading.current_thread().name))

运行结果如下:

Add1 is running >> 101
Add1 is running >> 102
Add1 is running >> 103
Add2 is running >> 3
Add1 is running >> 104
Add1 is running >> 105
Add2 is running >> 5
Add1 is running >> 106
MainThread Ending
Add1 is running >> 107

可以看到,前三秒线程1都被阻塞了。

注意, join 方法只能写在 start 方法之后。

5. 线程锁

首先我们先来进行这样一个实验,定义一个全局变量 num=0,使用两个线程分别对其进行1000000次加1以及1000000次加2,最终结果正确的话肯定是3000000对吧,那么最后结果是3000000吗?代码如下:

import threading
import time

num = 0

def job1():
    global num
    for i in range(1000000):
        num += 1

new_job1 = threading.Thread(target=job1, name='Add1')
new_job1.start()

for i in range(1000000):
    num += 2

# 等待线程执行完毕
time.sleep(5)
print('num = {}'.format(num))

最后输出结果为:

num = 1595678

并且每一次执行结果都不一样,这是这怎么回事呢?这是因为一个线程在修改数据的时候,另一个线程也在对数据进行修改,这就导致了脏数据的产生,数据库里面应该会经常有类似的问题,这也就有了线程锁产生的必要。下面我将会介绍Python中几种典型的锁。

5.1 互斥锁(Lock)

互斥锁只能开一次然后释放一次,一次开启后必须接上一次关闭,加锁的代码如下:

import threading
import time


num = 0

lock = threading.Lock()

def job1():
    global num
    for i in range(1000000):
        lock.acquire() # 加锁
        num += 1
        lock.release() # 释放锁
        # 上述代码也可以直接写为
        # with lock:
        # 	 num += 1

new_job1 = threading.Thread(target=job1, name='Add1')
new_job1.start()

for i in range(1000000):
    lock.acquire() # 加锁
    num += 2
    lock.release() # 释放锁

# 等待线程执行完毕
time.sleep(3)
print('num = {}'.format(num))

5.2 递归锁(RLock)

RLock与Lock最大的区别就是RLock可以开多次,再进行多次释放,也就是说RLock支持大锁里面套小锁。示例如下:

import threading, time


def run1():
    lock.acquire()
    print("grab the first part data")
    global num
    num += 1
    lock.release()
    return num


def run2():
    lock.acquire()
    print("grab the second part data")
    global num2
    num2 += 1
    lock.release()
    return num2


def run3():
    lock.acquire()
    res = run1()
    print('--------between run1 and run2-----')
    res2 = run2()
    lock.release()
    print(res, res2)


if __name__ == '__main__':
    num, num2 = 0, 0
    lock = threading.RLock()
    for i in range(3):
        t = threading.Thread(target=run3)
        t.start()

while threading.active_count() != 1:
    print(threading.active_count())
else:
    print('----all threads done---')
    print(num, num2)

5.3 信号量(Semaphore)

互斥锁同时只允许一个线程修改数据,而Semaphore是同时允许一定数量的线程修改数据,比如只有五个位置的餐桌,如果人坐满了,那么只有等一个人吃完后下一个人才能上桌。

下面设置信号量为3,每个线程执行三秒钟的时间,看看线程执行的时间是怎样的。

import threading
import time

# 设置信号量,即同时执行的线程数为3
lock = threading.BoundedSemaphore(3)

def job1():
    lock.acquire()
    print('{} is coming, {}'.format(threading.current_thread().name, time.strftime('%H:%M:%S',time.localtime(time.time()))))
    time.sleep(3)
    lock.release()

for i in range(10):
    new_job1 = threading.Thread(target=job1, name='Thread{}'.format(i))
    new_job1.start()

输出结果为:

Thread0 is coming, 16:44:41
Thread1 is coming, 16:44:41
Thread2 is coming, 16:44:41
Thread3 is coming, 16:44:44
Thread5 is coming, 16:44:44
Thread4 is coming, 16:44:44
Thread6 is coming, 16:44:47
Thread8 is coming, 16:44:47
Thread7 is coming, 16:44:47
Thread9 is coming, 16:44:50

上面的线程每三个是同一时间执行的,这也就说明了我们设置的信号量限制了同时执行的线程的数量。

5.4 事件(Event)

Event类会在全局定义一个Flag,当 Flag=False 时,调用 wait() 方法会阻塞所有线程;而当 Flag=True 时,调用 wait() 方法不再阻塞。形象的比喻就是“红绿灯”:在红灯时阻塞所有线程,而在绿灯时又会一次性放行所有排队中的线程。Event类有四个方法:

方法 描述
set() 将Flag设置为True
wait() 阻塞所有线程
clear() 将Flag设置为False
is_set() 返回bool值,判断Flag是否为True

Event的一个好处是:可以实现线程间通信,通过一个线程去控制另一个线程。

例如,这里设置两个线程,线程1对全局变量 num 每次加1,线程2对全局变量 num 每次加2,各持续1000000次,现要求线程1在线程2加了500000次且自身加了700000次时,不再进行加法操作,实现代码如下:

import threading
import time

num = 0
event = threading.Event()
event.set()     # 设定Flag = True
lock = threading.BoundedSemaphore(1)
def job1():
    global num
    for i in range(1000000):
    	# 如果加了70w次并且被阻塞,就跳出循环
        if i == 700000 and not event.is_set():
            break
        lock.acquire()
        num += 1
        lock.release()
    print('num = {}'.format(num))
    event.set()

new_job1 = threading.Thread(target=job1, name='Add1')
new_job1.start()

for i in range(1000000):
	# 如果执行了50w次,则阻塞进程
    if i == 500000:
        event.clear() # 设置Flag=False
        event.wait() # 阻塞进程
        print('num = {}'.format(num))
    lock.acquire()
    num += 2
    lock.release()

# 等待线程执行完毕
time.sleep(3)
print('num = {}'.format(num))

6. ThreadLocal

在多线程环境下,每个线程都有自己的数据。一个线程使用自己的局部变量比使用全局变量好,因为局部变量只有线程自己能看见,不会影响其他线程,而全局变量的修改必须加锁。

但是局部变量也有问题,就是在函数调用的时候,传递起来很麻烦,比如我们需要将所有线程的数据传到另一个函数中去,那么我们要每个数据都是用参数传递吗?这样太过于麻烦,形式如下:

import threading

def add(n):
    return n + n

def divid(n):
    return n / 2

def times(a, b):
    return a * b

def job1(num):
    num_add = add(num)
    num_divid = divid(num)
    n = times(num_add, num_divid)
    print('{} result >> {}'.format(threading.current_thread().name, n))

for i in range(5):
    t = threading.Thread(target=job1, args=(i,), name='Thread{}'.format(i))
    t.start()

输出如下:

Thread0 result >> 0.0
Thread1 result >> 1.0
Thread2 result >> 4.0
Thread3 result >> 9.0
Thread4 result >> 16.0

很容易就能看出,一次次的在job1中传递参数太过麻烦了,如果参数少还好,参数多的话,那简直会晕了头,那么,这就需要使用到 ThreadLocal 了。

ThreadLocal 能够管理每一个线程的数据,只需要将线程的数据放进去,然后再读出来即可,其会自动区分每个线程,使得数据不会混合,将上述例子改为 ThreadLocal 后,代码如下:

import threading

# 创建全局ThreadLocal对象
local_data = threading.local()
def add():
	# 取出ThreadLocal中的数据
    n = local_data.num
    local_data.num_add = n + n

def divid():
    n = local_data.num
    local_data.num_divid = n / 2

def times():
    local_data.result = local_data.num_add * local_data.num_divid

def job1(num):
	# 将数据存入ThreadLocal中
    local_data.num = num
    add()
    divid()
    times()
    print('{} result >> {}'.format(threading.current_thread().name, local_data.result))

for i in range(5):
    t = threading.Thread(target=job1, args=(i,), name='Thread{}'.format(i))
    t.start()

可以看到,如上代码中的数据根本没有参数传递,直接将所有的数据都存入了 ThreadLocal 对象中,就像在类中的 self 一样,十分的方便简洁。

7. 线程池

不是线程数量越多,程序的执行效率就越快。线程也是一个对象,是需要占用资源的,线程数量过多的话肯定会消耗过多的资源,同时线程间的上下文切换也是一笔不小的开销,所以有时候开辟过多的线程不但不会提高程序的执行效率,反而会适得其反使程序变慢,得不偿失。

为了防止无尽的线程被初始化,于是线程池就诞生了。当线程池初始化时,会自动创建指定数量的线程,有任务到达时直接从线程池中取一个空闲线程来用即可,当任务执行结束时线程不会消亡而是直接进入空闲状态,继续等待下一个任务。而随着任务的增加线程池中的可用线程必将逐渐减少,当减少至零时,任务就需要等待了。这就最大程度的避免了线程的无限创建,当所需要使用的线程不知道有多少时,一般都会使用线程池。

在 python 中使用线程池有两种方式,一种是基于第三方库 threadpool,另一种是基于 python3 新引入的库 concurrent.futures.ThreadPoolExecutor,这里我们介绍一下后一种。

7.1 基本使用

首先先了解以下方法

  • submit
    submit(fn, *args, **kwargs)
    
    其中 fn 为方法名,其后的 *args, **kwargs 为该方法的参数。
  • ThreadPoolExecutor
    ThreadPoolExecutor(max_workers=None, thread_name_prefix='', initializer=None, initargs=())
    
    最常用的是 max_workers 参数,即线程池中的线程数。

下面用一个例子来说明方法的使用,假如我们需要向线程池申请2单位的线程,运行一个加法操作并返回结果,且每个加法操作会等待3秒,则代码如下:

import time
from concurrent.futures import ThreadPoolExecutor

# 对两数进行加法,并停留3秒
def add(a, b):
    time.sleep(3)
    return a + b

task = []
# 加法的两个因数
list_a = [1, 2, 3, 4, 5]
list_b = [6, 7, 8, 9, 10]
# 使用with上下问管理器,就不用管如何关线程池了
with ThreadPoolExecutor(2) as pool:
	# 将每一个线程都进行提交
    for i in range(len(list_a)):
        task.append(pool.submit(add, list_a[i], list_b[i]))
	
	# 输出每个线程运行的结果
    for i in task:
        print('result = {}'.format(i.result()))

result 方法能够输出对应的线程运行后方法的返回结果,如果线程还在运行,那么其会一直阻塞在那里,直到该线程运行完,当然,也可以设置 result(timeout),即如果调用还没完成那么这个方法将等待 timeout 秒。如果在 timeout 秒内没有执行完成,concurrent.futures.TimeoutError 将会被触发。

7.2 as_completed 方法

as_completed(fs, timeout=None)

返回一个包含 fs 所指定的 Future 实例的迭代器,在没有任务完成的时候,会一直阻塞,如果设置了 timeout 参数,timeout 秒之后结果仍不可用,则返回的迭代器将引发 concurrent.futures.TimeoutErrortimeout 可以为整数或浮点数。 如果 timeout 未指定或为 None,则不限制等待时间。

当有某个任务完成的时候,该方法会 yield 这个任务,就能执行 for 循环下面的语句,然后继续阻塞住,循环到所有的任务结束。同时,先完成的任务会先返回给主线程。

将上面的程序改为使用 as_completed 后为:

import time
from concurrent.futures import ThreadPoolExecutor, as_completed

def add(a, b):
    time.sleep(3)
    return a + b

task = []
list_a = [1, 2, 3, 4, 5]
list_b = [6, 7, 8, 9, 10]
with ThreadPoolExecutor(2) as pool:
    for i in range(len(list_a)):
        task.append(pool.submit(add, list_a[i], list_b[i]))
	
	# 使用as_completed遍历
    for i in as_completed(task):
        print('result = {}'.format(i.result()))

该方法与第一种的直接遍历所具有的优势是,不需要等待所有线程全部返回,而是每返回一个子线程就能够处理,上面的result方法会阻塞后面的线程。

7.3 wait方法

wait() 方法如下:

wait(fs, timeout=None, return_when=ALL_COMPLETED)

fs 为指定的 Future 实例,timeout 可以用来控制返回前最大的等待秒数。 timeout 可以为 int 或 float 类型。 如果 timeout 未指定或为 None ,则不限制等待时间。return_when 指定此函数应在何时返回。它必须为以下常数之一:

常数 描述
FIRST_COMPLETED 等待第一个线程结束时返回,即结束等待
FIRST_EXCEPTION 函数将在任意可等待对象因引发异常而结束时返回。当没有引发任何异常时它就相当于 ALL_COMPLETED
ALL_COMPLETED 函数将在所有可等待对象结束或取消时返回

我们在上例中添加一个 wait 方法如下:

import time
from concurrent.futures import ThreadPoolExecutor, wait, ALL_COMPLETED

def add(a, b):
    time.sleep(3)
    return a + b

task = []
list_a = [1, 2, 3, 4, 5]
list_b = [6, 7, 8, 9, 10]
with ThreadPoolExecutor(2) as pool:
    for i in range(len(list_a)):
        task.append(pool.submit(add, list_a[i], list_b[i]))
	
	# 等待所有线程执行完再往下
    wait(task, return_when=ALL_COMPLETED)

    for i in task:
        print('result = {}'.format(i.result()))

7.4 map方法

map 方法参数如下:

map(func, *iterables, timeout=None, chunksize=1)

func 参数为多线程指向的方法名,*iterables 实际上是该方法的参数,该方法的参数必须是可迭代对象,即元组或列表等,不能单纯的传递 int 或字符串,如果 timeout 设定的时间小于线程执行时间会抛异常 TimeoutError,默认为 None 则不加限制。

使用 map 方法,有两个特点:

  • 无需提前使用submit方法
  • 返回结果的顺序和元素的顺序相同,即使子线程先返回也不会获取结果

将上例使用 map 方法后的示例如下:

import time
from concurrent.futures import ThreadPoolExecutor

def add(a, b):
    time.sleep(3)
    return a + b

task = []
list_a = [1, 2, 3, 4, 5]
list_b = [6, 7, 8, 9, 10]
with ThreadPoolExecutor(2) as pool:
	# map中list_a与list_b按照下标一一对应
    for result in pool.map(add, list_a, list_b):
        print('result = {}'.format(result))

8. Python线程真相

实际上,Python中的多线程其实并没有我们以为的那么有用,Python中的多线程其实是一种假象的多线程。

Python的线程虽然是真正的线程,但解释器执行代码时,有一个GIL锁:Global Interpreter Lock,任何Python线程执行前,必须先获得GIL锁,然后,每执行100条字节码,解释器就自动释放GIL锁,让别的线程有机会执行。这个GIL全局锁实际上把所有线程的执行代码都给上了锁,所以,多线程在Python中只能交替执行,即使100个线程跑在100核CPU上,也只能用到1个核。

GIL是Python解释器设计的历史遗留问题,通常我们用的解释器是官方实现的CPython,要真正利用多核,除非重写一个不带GIL的解释器。

所以,在Python中,可以使用多线程,但不要指望能有效利用多核。如果一定要通过多线程利用多核,那只能通过C扩展来实现,不过这样就失去了Python简单易用的特点。

这就相当于我有12个核的CPU,尽管使用了Python的多线程,比如我一共开了12个线程,但是,不管这个线程时占用一个内核还是12个内核,每一个时间段都只能有1个线程在CPU中进行运行,然后根据时间片轮转的方式,切换到下一个线程,下一个线程再进行运行。所以说,Python中的多线程实际上是一种并发而不是并行。但是,Python其实是能够实现并行的,那就是利用多进程来实现。

下面我们参照这篇文章的回答来进行实验验证。

我的电脑是12核的,下面我写一个12线程的无限循环,再看看CPU的利用率。

from threading import Thread

def loop():
    while True:
        pass


if __name__ == '__main__':
    for i in range(12):
        t = Thread(target=loop)
        t.start()

    while True:
        pass

在程序运行了约20秒后,CPU利用率如下,可以发现,CPU的利用率基本上没有什么变化,下面我们看看使用多进程时的CPU利用率。

Python多线程详解_第1张图片

这里使用多进程开12个无限循环的进程,代码如下。

from multiprocessing import Process

def loop():
    while True:
        pass

if __name__ == '__main__':
    for i in range(12):
        t = Process(target=loop)
        t.start()

    while True:
        pass

CPU利用率如下,可以看到,COU利用率一瞬间就冲到了100%,这表示Python中的多进程实际上是可以并行运行的,但是多线程却是并发运行的。
Python多线程详解_第2张图片

参考文章

[1] : https://www.liaoxuefeng.com/wiki/1016959663602400/1017629247922688
[2] : https://blog.csdn.net/weixin_44850984/article/details/89165731
[3] : https://www.runoob.com/python3/python3-multithreading.html
[4] : https://zhuanlan.zhihu.com/p/490353142
[5] : https://blog.csdn.net/Elon15/article/details/125350491
[6] : https://www.cnblogs.com/fjfsu/p/15709155.html
[7] : https://blog.csdn.net/hhl134/article/details/122366629
[8] : https://www.cnblogs.com/goldsunshine/p/16878089.html
[9] : https://docs.python.org/zh-cn/3.7/library/concurrent.futures.html

你可能感兴趣的:(Python,python,django,开发语言)