脚本编写面试题, 如何使用 Python 的 threading 模块实现并发执行任务?

Step 1

Q:: 如何使用 Python 的 threading 模块实现并发执行任务？

A:: Python 的 threading 模块提供了一个 Thread 类用于实现并发执行任务。可以通过继承 Thread 类或直接创建 Thread 对象并传入目标函数来实现。以下是一个简单示例：

 
import threading
 
def task(name):
    print(f'Task {name} is running')
 
threads = []
for i in range(5):
    t = threading.Thread(target=task, args=(i,))
    threads.append(t)
    t.start()
 
for t in threads:
    t.join()
 

上述代码创建了五个线程，每个线程运行一次 task 函数。线程启动后会并发执行，最后使用 join 方法等待所有线程执行完毕。

Step 2

Q:: Python 中的 GIL 是什么？对多线程有什么影响？

A:: GIL（Global Interpreter Lock，全局解释器锁）是 CPython 实现中用来保护访问 Python 对象的全局锁。它确保同一时间只有一个线程执行 Python 字节码。这意味着在 CPU 密集型任务中，Python 的多线程并不能真正并行执行，而是交替执行。GIL 对 I/O 密集型任务影响较小，因为 I/O 操作通常会释放 GIL。

Step 3

Q:: 如何避免线程中的竞争条件？

A:: 可以使用 threading 模块中的 Lock 对象来避免竞争条件。Lock 对象提供了一种简单的机制来确保在同一时间只有一个线程可以执行特定的代码段。使用方式如下：

 
import threading
 
lock = threading.Lock()
 
# 使用锁保护共享资源
lock.acquire()
try:
    # 访问共享资源
    pass
finally:
    lock.release()
 

也可以使用 with 语句来自动管理锁的获取和释放：

 
with lock:
    # 访问共享资源
    pass
 

Step 4

Q:: 什么是死锁？如何避免死锁？

A:: 死锁是指两个或多个线程相互等待对方释放资源，从而导致程序无法继续执行。避免死锁的方法包括：

1. 避免嵌套锁：尽量减少使用嵌套锁来降低死锁风险。 2. 尽量采用超时锁：使用 Lock 的 acquire 方法时指定 timeout 参数，避免无限期等待。 3. 使用更高级的并发工具：如 queue 模块中的 Queue 类，它是线程安全的，可以用来在线程间传递数据而不需要使用显式的锁。

Step 5

Q:: 如何使用 threading 模块中的 Condition 对象实现线程间通信？

A:: Condition 对象允许一个线程等待，直到另一个线程通知其某个条件已经发生。典型用法如下：

 
import threading
 
condition = threading.Condition()
 
# 线程 A
with condition:
    condition.wait()  # 等待条件发生
    # 执行一些操作
 
# 线程 B
with condition:
    # 更新条件
    condition.notify()  # 通知等待的线程条件已满足
 

Step 1

Q:: 如何使用 Python 的 threading 模块实现并发执行任务？

A:: Python 的 threading 模块允许通过线程实现并发执行任务。使用 threading 模块的基本步骤包括： 1. 创建一个 Thread 对象，并将目标函数和参数传递给它。 2. 使用 start() 方法启动线程，start() 方法会触发目标函数的执行。 3. 使用 join() 方法等待线程完成，确保主线程在子线程完成后再继续执行。

代码示例：

 
import threading
 
def task(name):
    print(f'Task {name} is running')
 
threads = []
for i in range(5):
    thread = threading.Thread(target=task, args=(i,))
    threads.append(thread)
    thread.start()
 
for thread in threads:
    thread.join()
 

这个示例创建了5个线程，并发执行 task 函数，最后使用 join 方法等待所有线程执行完成。

Step 2

Q:: Python threading 模块中，什么是 GIL（全局解释器锁）？

A:: GIL，全局解释器锁，是 Python 中的一个机制，用来防止多个原生线程同时执行 Python 字节码。由于 Python 的内存管理不是线程安全的，GIL 确保了每个时刻只有一个线程在执行 Python 字节码。这在 CPU 密集型任务中限制了多线程并发的效率，因为在任何时刻只有一个线程能执行。这也是为什么在多核 CPU 环境下，使用多线程的 Python 程序通常无法充分利用所有核心的原因之一。

Step 3

Q:: 如何在 Python 中使用 threading 模块实现线程间通信？

A:: 在 Python 中，可以使用 Queue 模块来实现线程间通信。Queue 是线程安全的，适合在生产者-消费者模式下使用。

代码示例：

 
import threading
import queue
 
def producer(q):
    for i in range(5):
        q.put(i)
        print(f'Produced {i}')
 
def consumer(q):
    while True:
        item = q.get()
        if item is None:
            break
        print(f'Consumed {item}')
 
q = queue.Queue()
producer_thread = threading.Thread(target=producer, args=(q,))
consumer_thread = threading.Thread(target=consumer, args=(q,))
 
producer_thread.start()
consumer_thread.start()
 
producer_thread.join()
q.put(None)  # 发送结束信号
consumer_thread.join()
 

在这个例子中，生产者线程将数据放入队列，消费者线程从队列中取数据，实现了线程间的通信。