Python语法速查： 20. 线程与并发

返回目录

本篇索引

（1）线程基本概念

（2）threading模块

（3）线程间同步原语资源

（4）queue

（1）线程基本概念

当应用程序需要并发执行多个任务时，可以使用线程。多个线程（thread）同时运行在一个进程（process）的内部， 它们可以共享访问本进程内的全局变量数据和资源。各个线程之间的调度由操作系统负责， 具体做法是：给每个线程分配一个小的时间片，并在所有的线程之间循环切换。在具有多核的CPU上， 操作系统有时会安排尽可能使用每个CPU，从而并行执行线程。

并发编程的复杂性在于，多个线程可能同时更新一个数据，导致数据的损坏或不一致（术语叫做：竞争）， 要解决这个问题，必须使用互斥锁或其他类似的同步手段保护这些数据。

Python解释器使用了内部的GIL（Global Interpreter Lock，全局解释器锁）， 这限制了Python程序只能在一个处理器上运行。如果一个应用程序的大部分是I/O密集型的， 那么使用线程是没有问题的。而如果是CPU密集型的，那使用多个线程没任何好处，还会降低运行速度。 因此对于计算密集型的任务，最好使用C扩展模块或multiprocessing模块来代替。 C扩展具有释放解释器锁和并行运行的选项，前提是释放锁时不与解释器进行交互。 multiprocessing模块将工作分派给不受锁限制的单独子进程。

使用多线程编程还要注意一个问题：开的线程的数量级不能太大。例如，一台使用线程的网络服务器对于100个线程工作情况良好， 但如果增加到10000个线程，性能就会变得非常糟糕。因为每个线程都需要有自己的系统资源， 而且还会产生线程上下文切换、锁和其他相关开销，算下来是个不小的开销。 对这种I/O密集型应用，比较常见的做法是将程序编写为：异步事件处理机制的结构，比如“协程”。 使用异步和协程的方式编程，可以比较轻松地处理诸如10000个连接的情况。

没有任何方法可以强制终止或挂起其他线程！这是设计上的原因。因此，线程只能自己挂起或自己终止。

（2）threading模块

threading模块提供Thread类和各种同步原语，用于编写多线程的程序。 threading模块可创建：Thread对象、Timer对象、 Lock对象、RLock对象等。

● Thread对象

Thread类用于表示单独的控制线程，创建新线程的语法如下：

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

此函数创建一个新的线程实例，target是一个可调用对象（线程启动时，run()方法将调用此对象）， name是线程名称，默认将创建一个名为 “Target-N” 格式的唯一名称。 args、kwargs是传递给target函数的参数元组、参数字典。

Thread实例支持以下属性和方法

● 线程使用实例

通常 Python 解释器退出之前，会等待所有线程终止。但是，若将创建的线程的daemon设置为 True， 会使解释器在主线程结束后立即退出程序，这些daemon为 True的线程将即时被销毁。

下例中，线程 t 每5秒从后台激活激活运行一次；30秒后，主线程结束，整个Python程序退出：

import threading
import time

def clock(interval):
    while True:
        print("The time is %s" % time.ctime())
        time.sleep(interval)

t = threading.Thread(target=clock, args=(5,))
t.daemon = True
t.start()

time.sleep(30)

下例为将同一个线程定义为一个 Thread 的子类：

import threading
import time

class ClockThread(threading.Thread):
    def __init__(self, interval):
        threading.Thread.__init__(self)
        self.daemon = True
        self.interval = interval
    def run(self):
        while True:
            print("The time is %s" % time.ctime())
            time.sleep(self.interval)          

t = ClockThread(5)
t.start()

time.sleep(30)  

● Timer对象

Timer对象用于在稍后某个时间执行一个函数，调用语法如下：

Timer(interval, func [,args [,kwargs]])

此函数创建定时器对象，在interval秒之后运行函数func， args、kwargs是传递给func函数的参数元组、参数字典。

Timer实例支持以下方法：

● 实用工具函数

（3）线程间同步原语资源

● 锁（Lock）

锁（或称为“互斥锁”）有2个状态：已锁定、未锁定。如果锁处于已锁定状态，尝试获取锁的线程将被阻塞， 直到锁被释放为止。如果有多个线程等待获取锁，当锁被释放时，只有一个线程能获得它，具体哪个线程随机。 创建锁的语法如下，初始状态为“未锁定”：

threading.Lock()

Lock实例支持以下方法

● 可重入锁（RLock）

可重入锁（RLock）类似于Lock对象，但同一个线程可以多次获取它。 这允许拥有锁的线程执行嵌套的acquire()和release()操作。 在这种情况下，只有最外层的release()操作才能将锁重置为“未锁定”状态。

创建可重入锁的语法如下：

threading.RLock()

RLock实例支持以下方法

● 信号量（Semaphore）

信号量是一个基于计数器的同步原语，每次调用acquire()方法时此计数器减1， 每次调用release()方法时此计数器加1。如果计数器为0，acquire()方法将会阻塞。 直到其他线程调用release()方法为止。

创建信号量对象的语法如下（value是计数器初始值，默认为1）：

threading.Semaphore([value])

以下创建有边界的信号量对象（BoundedSemaphore），区别是release()操作的次数不能超过acquire()次数：

threading.BoundedSemaphore([value])

Semaphore实例支持以下方法

“信号量”和“互斥锁”之间的差别在于，信号量可用于发信号。例如：可以从不同线程调用 acquire()和release()方法，以便在生产者和消费者线程之间进行通信。 也可以用后面的“条件变量”来达成。

● 事件（Event）

“事件”用于线程间通信。一个线程发出事件，一个或多个其他线程等待它。 Event实例内部管理着一个标志，可以用set()方法将它设为True， clear()方法设为False，wait()方法将阻塞线程，知道标志为True。

创建事件的语法如下：

threading.Event()

Event实例支持以下方法

“事件”不适合用于生产者-消费者问题，因为事件只有True和False两种状态， 处理过程中信号可能丢失。最好使用“条件变量”。

● 条件变量（Condition）

“条件变量”是另一种同步原语，典型用于生产者-消费者问题。

创建条件变量的语法如下，lock是可选的Lock或RLock实例，若缺省则创建新的RLock实例

threading.Condition([lock])

Condition实例支持以下方法

下面为使用条件变量的模板：

import threading

cv = threading.Condition()

def producer():
    while True:
        cv.acquire()
        produce_item()
        cv.notify()
        cv.release()

def consumer():
    while True:
        cv.acquire()
        while not item_is_available():
            cv.wait()   # 等待直到有项出现
        cv.release()
        consume_item()

如果存在多个线程等待同一个条件，notify()操作可能唤醒他们中的一个或多个。 因此某个线程被唤醒后，可能发现它等待的条件不存在了，所以在consumer()函数中使用while循环， 如果线程醒来，但是生成的项已经消失，它就会回去等待下一个信号。

● 使用线程间资源的注意点

使用以上Lock等之类的线程间资源时，必须非常小心，依赖锁的代码应保证出现异常时正确地释放锁 否则可能导致死锁，典型的代码如下所示：

try:
    lock.acquire()
    # 关键部分
    ......
finally:
    lock.release()

使用上下文管理协议（with），更加简洁：

with lock:
    # 关键部分
    ......

另外，编写代码时，一般应该避免同时获取多个锁。

（4）queue

queue模块实现了各种“多生产者-多消费者队列”，可用于在执行的多个线程间安全地交换信息。 一般来说，线程间通信最佳的方式就是使用queue，者比前面的诸如“锁”之类的资源都要好用。

queue模块定义了以下3种不同的队列类型，创建语法与说明如下：

队列支持以下实例方法：

● 使用队列的示例

注意下例中q.task_done()和q.join()的用法， 它们将使得线程在处理完所有项后关闭。

import threading
from queue import Queue

class WorkerThread(threading.Thread):
    def __init__(self, *args, **kwargs):
        threading.Thread.__init__(self, *args, **kwargs)
        self.input_queue = Queue()

    def send(self, item):
        self.input_queue.put(item)

    def close(self):
        self.input_queue.put(None)
        self.input_queue.join()

    def run(self):
        while True:
            item = self.input_queue.get()
            if item is None:
                break
            # 处理项
            print(item)
            self.input_queue.task_done()
        # 完成
        self.input_queue.task_done()
        return

# 使用示例
w = WorkerThread()
w.start()
w.send(‘hello‘)
w.send(‘world‘)
w.close()

返回目录

原文地址：https://www.cnblogs.com/initcircuit/p/12273589.html