Python中的并发编程(2)线程的实现

简介: Python中的并发编程(2)线程的实现

Python中线程的实现

1. 线程

在Python中,threading 库提供了线程的接口。我们通过threading 中提供的接口创建、启动、同步线程。

例1. 使用线程旋转指针

想象一个场景:程序执行了一个耗时较长的操作,如复制一个大文件,我们希望这个过程中程序显示一个动画,表示程序正常运行没有卡死。


简化一下:启动一个函数,执行 3 秒。在这3秒内,在终端持续显示指针旋转的动画。下面用线程来实现这个操作。


注:本例代码主要来自《流畅的Python》(第二版) 19.4.

1首先我们定义旋转函数spin和阻塞函数slow

spin函数每隔0.1s依次打印\|/-,看起来就像是指针转动:

import itertools
import time
def spin(msg: str) -> None:  
  for char in itertools.cycle(r'\|/-'): 
    status = f'\r{char} {msg}' 
    print(status, end='', flush=True)
    time.sleep(0.1)
  blanks = ' ' * len(status)
  print(f'\r{blanks}\r', end='')


if __name__ == '__main__':
  spin("thinking...")

slow函数用来模拟一个耗时的操作。这里我们直接调用time.sleep(3) 等待3秒,然后返回一个结果。

# 阻塞3秒,并返回42
def slow() -> int:
  time.sleep(3) 
  return 42

调用time.sleep() 阻塞所在的线程,但是释放 GIL,其他 Python 线程可以继续运行。

现在,我们要用线程实现并发。看起来就像是slowspin同时进行。

下面对spin函数做了一些修改,通过threading.Event信号量来同步线程。

import itertools
import time
from threading import Thread, Event

# 旋转
def spin(msg: str, done: Event) -> None:  # done用于同步线程
  for char in itertools.cycle(r'\|/-'): 
    status = f'\r{char} {msg}' 
    print(status, end='', flush=True)
    if done.wait(.1): #等待/阻塞 。除非有其他线程set了这个事件,则返回True;或者经过指定的时间(0.1s)后,返回 False。
      break
  blanks = ' ' * len(status)
  print(f'\r{blanks}\r', end='')

# 阻塞3秒,并返回42
def slow() -> int:
  time.sleep(3) 
  return 42

使用线程来并发执行两个函数。

下面我们只手动启动了一个spinner线程,因为程序本身就有一个主线程。

def supervisor() -> int: 
  done = Event()  # 信号量,用于线程同步
  spinner = Thread(target=spin, args=('thinking!', done)) # 使用Thread创建线程实例spinner。
  print(f'spinner object: {spinner}') 
  spinner.start() # 启动spinner线程
  result = slow()  # 调用slow,阻塞 main 线程。同时,次线程spinner运行旋转指针动画
  done.set() # 设置done为真,唤醒等待done的线程。结束spinner中的循环。
  spinner.join() # 等待spinner 线程结束。-貌似这里加不加都不影响。
  return result
  
def main() -> None:
  result = supervisor() 
  print(f'Answer: {result}')
  
if __name__ == '__main__':
  main()

程序的执行顺序,主要步骤都发生在supervisor函数中,我们跳过main从supervisor开始看。

由于GIL的存在,同一时刻只有一个线程在执行。所以下面是一个顺序执行的过程。

执行过程大致如下:

主线程:创建spinner线程,启动spinner线程

spinner线程:输出字符,然后遇到done.wait(.1) 阻塞自己。

主线程:调用slow函数,遇到time.sleep(3) 阻塞

spinner线程:done.wait(.1) 超过了0.1秒返回False,继续输出字符。重复进行阻塞0.1秒、输出字符。

3秒后…

主线程:slow执行完毕,返回结果42。主线程继续执行done.set(),这会唤醒等待done的线程spinner。

spinner线程:运行到done.wait(.1),由于主线程执行了done.set()使得这里的结果为True,所以执行break,结束循环。执行循环下面的print语句后spinner线程结束。

主线程:返回结果。


例2.计算因子

第二个例子我们看一个(失败的)并行计算的例子:

我们希望用n个线程并行计算n个数各自的因子。


注:本例代码来自《Effective Python》(第二版) 第53章

基准方法

逐个计算。

import time

# 计算number的因子
def factorize(number):
    for i in range(1, number + 1):
        if number % i == 0:
            yield i

numbers = [2139079, 1214759, 1516637, 1852285, 14256346, 12456533]
start = time.time()
 
for number in numbers:
    list(factorize(number))
 
end = time.time()
delta = end - start
print(f'串行方法花费了 {delta:.3f} 秒')

多线程方式

可以像例1中使用Thread函数实现线程:

def get_factor(number):
    factors = list(factorize(number))
    return factors

start = time.time()
threads = []
for number in numbers:
    thread = Thread(target=get_factor, args=(number,))
    thread.start() # 启动
    threads.append(thread)
    
# 等待所有线程完成
for thread in threads:
    thread.join() # 等待完成

end = time.time()
delta = end - start
print(f'Thread方法花费了 {delta:.3f} 秒')

实现线程的另一种方式是继承Thread类并实现run方法:

from threading import Thread

# 继承Thread,需要实现run方法,在run方法中执行要做的事情
class FactorizeThread(Thread):
    def __init__(self, number):
        super().__init__()
        self.number = number
 
    def run(self):
        self.factors = list(factorize(self.number))


start = time.time()

threads = []
for number in numbers:
    thread = FactorizeThread(number)
    thread.start() # 启动
    threads.append(thread)
    
# 等待所有线程完成
for thread in threads:
    thread.join() # 等待完成
 
end = time.time()
delta = end - start
print(f'Thread方法花费了 {delta:.3f} 秒')

运行结果:

你会发现这个多线程的版本并没有变快,这并不意外。

介绍线程时说过,因为GIL的存在,多线程无法同时执行,甚至因为创建和切换线程产生额外的开销导致耗时增加。

小结

在GIL的限制下,Python线程对于并行计算没有用处,但是对于等待(IO、网络、后台任务)是有用处的。下一节我们会看一些Python线程的实际案例。

相关文章
|
8天前
|
并行计算 数据处理 Python
Python并发编程迷雾:IO密集型为何偏爱异步?CPU密集型又该如何应对?
【7月更文挑战第17天】Python并发编程中,异步编程(如`asyncio`)在IO密集型任务中提高效率,利用等待时间执行其他任务。但对CPU密集型任务,由于GIL限制,多线程效率不高,此时应选用`multiprocessing`进行多进程并行计算以突破限制。选择合适的并发策略是关键:异步适合IO,多进程适合CPU。理解这些能帮助构建高效并发程序。
19 6
|
9天前
|
安全 Python
在Python中,实现多线程
【7月更文挑战第16天】在Python中,实现多线程
21 6
|
7天前
|
开发框架 并行计算 .NET
从菜鸟到大神:Python并发编程深度剖析,IO与CPU的异步战争!
【7月更文挑战第18天】Python并发涉及多线程、多进程和异步IO(asyncio)。异步IO适合IO密集型任务,如并发HTTP请求,能避免等待提高效率。多进程在CPU密集型任务中更优,因可绕过GIL限制实现并行计算。通过正确选择并发策略,开发者能提升应用性能和响应速度。
|
7天前
|
监控 安全 调度
在Python中,线程管理
【7月更文挑战第18天】在Python中,线程管理
8 3
|
10天前
|
数据处理 Python
深入探索:Python中的并发编程新纪元——协程与异步函数解析
【7月更文挑战第15天】Python 3.5+引入的协程和异步函数革新了并发编程。协程,轻量级线程,由程序控制切换,降低开销。异步函数是协程的高级形式,允许等待异步操作。通过`asyncio`库,如示例所示,能并发执行任务,提高I/O密集型任务效率,实现并发而非并行,优化CPU利用率。理解和掌握这些工具对于构建高效网络应用至关重要。
21 6
|
7天前
|
UED 开发者 Python
Python并发编程新纪元:异步编程如何重塑IO与CPU密集型任务的处理方式?
【7月更文挑战第18天】Python异步编程提升IO任务效率,非阻塞模式减少等待时间,优化用户体验。asyncio库与await关键字助力编写非阻塞代码,示例展示异步HTTP请求。CPU密集型任务中,异步编程结合多进程可提升效率。异步编程挑战包括代码复杂性,解决策略包括使用类型提示、异步框架及最佳实践。异步编程重塑任务处理方式,成为现代Python开发的关键。
12 2
|
7天前
|
开发者 Python
Python线程
【7月更文挑战第18天】Python线程
12 2
|
7天前
|
Python
Python线程是操作系统能够进行运算的最小单位
【7月更文挑战第18天】Python线程是操作系统能够进行运算的最小单位
9 1
|
8天前
|
数据采集 并行计算 数据处理
工具人必看:Python并发编程工具箱大揭秘,IO与CPU密集型任务的最佳拍档!
【7月更文挑战第16天】Python并发编程助力IO密集型(asyncio+aiohttp,异步Web爬虫示例)和CPU密集型(multiprocessing,并行计算数组和)任务。asyncio利用单线程异步IO提升Web应用效率,multiprocessing通过多进程克服GIL限制,实现多核并行计算。善用这些工具,可优化不同场景下的程序性能。
11 1
|
10天前
|
调度 Python
揭秘Python并发编程核心:深入理解协程与异步函数的工作原理
【7月更文挑战第15天】Python异步编程借助协程和async/await提升并发性能,减少资源消耗。协程(async def)轻量级、用户态,便于控制。事件循环,如`asyncio.get_event_loop()`,调度任务执行。异步函数内的await关键词用于协程间切换。回调和Future对象简化异步结果处理。理解这些概念能写出高效、易维护的异步代码。
13 2