python-线程

Python对多线程提供了很好的支持，Python中多线程相关的模块包括：thread，threading，Queue。可以方便地支持创建线程、互斥锁、信号量、同步等特性。

1. thread：多线程的底层支持模块，除了其中提供的 Lock 原语外，一般不建议使用。

2. threading：基于 thread 模块，将一些线程的操作对象化，该模块提供下列类：

　　Thread，线程类

　　Timer，与Thread类似，但要等待一段时间后才开始运行

　　Lock，锁原语，和 thread 模块提供的 Lock 相同

　　RLock，可重入锁。使单线程可以再次获得已经获得的锁

　　Condition，条件变量，能让一个线程停下来，等待其他线程满足某个“条件”

　　Event，通用的条件变量。多个线程可以等待某个事件发生，在事件发生后，所有的线程都被激活

　　Semaphore，为等待锁的线程提供一个类似“等候室”的结构

3. Queue：实现了多生产者（Producer）、多消费者（Consumer）的队列，支持锁原语，能够在多个线程之间提供很好的同步支持。提供的类：

　　Queue队列

　　LifoQueue后入先出（LIFO）队列

　　PriorityQueue 优先队列

 

Thread in Python

1.1 Thread对象的创建

　　通过实例化Thread类型获得一个Thread对象：

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

　　参数的含义：

• 　　name：新线程的名称，如果没有指定，python会为其生成一个随机的唯一名称；
• 　　target：新线程中将要执行的函数；t.run() 会调用 target(*args, **kwargs)
• 　　args和kwargs：这是传递给线程中运行的主函数 target 的参数，当线程开始运行时，将会以这些参数调用执行主函数 target()。

1.2 Thread对象的方法

1	t.getName()

　　返回线程当前的名字。

1	t.setName(name)

　　设置线程的名字，线程的名称并不要求唯一。

1	t.isAlive()

　　判断这个线程是否还在运行中（active）——已经调用了start() 而 run() 还没有执行结束。

1	t.isDaemon()

　　判断线程是不是一个daemon线程，初始状态下，线程 t1 只有在创建自己的线程 t0 是daemon时，自己才是daemon的。

1	t.setDaemon(daemonic)

　　把线程的daemon标志设为daemonic（真或假）

　　daemon 线程是指，即使这个线程 t 的状态是 active，Python也可以终止 t（可能是通过终止 t 所在的进程）；非daemon线程没有终止前，Python会一直保持运行直到其终止。

　　setDaemon()需要在start()之前调用。

1	t.join(timeout=None)

　　这个函数需要注意，比如在一个线程 t1 的执行流程中调用 t2.join()，则 t1 阻塞直到 t2 线程执行结束，如果指定 timeout，则 t1 最多阻塞timeout秒，否则 t1 将一直等下去。

　　join()只能在start()之后调用；

1

t.run()

　　线程通过 run() 调用传入的主函数 target，不要直接调用run()，而是调用start()函数，start()函数会调用run()。

1

t.start()

　　开始线程执行

Python线程运行的流程

　1. 创建一个线程 t= threading.Thread()，此时新创建的线程并不会立即执行；

　2. 如果想要将 t 设置为守护线程，在调用 t.start() 之前调用 t.setDaemon(True)；否则忽略本步；

　3. 调用 t.start()，此时线程开始执行，状态更新为 active。更具体的，start() 会进一步调用 run() 函数，run() 函数再去调用创建线程对象时传入的主函数 target，从而让线程有了执行的具体内容；

　4. 当线程中的主函数执行完成或遇到未处理的异常时，线程终止执行；daemon线程也可能因为所在进程终止而被Python终止。

 

Python线程同步机制

　threading 模块提供的线程同步原语包括：Lock、RLock、Condition、Event、Semaphore等对象。

1. Lock

1.1 Lock对象的创建

　　Lock是Python中最底层的同步机制，直接由底层模块 thread 实现，每个lock对象只有两种状态——上锁和未上锁，不同于下文的RLock对象，Lock对象是不可重入的，也没有所属的线程这个概念。

　　可以通过下面两种方式创建一个Lock对象，新创建的 Lock 对象处于未上锁的状态：

1 2	thread.allocate_lock() threading.Lock()

　　但他们本质上都是在 thread 模块中实现的。

例如：

1 2 3 4 5

>>> l = threading.Lock() >>> type(l) <type 'thread.lock'> >>> l <thread.lock object at 0x0000000001C8F190>

1.2 lock对象的方法

　　lock对象提供三种方法：acquire()、locked()和release()

1	l.acquire(wait=True)

　　该函数需要结合参数 wait 进行讨论：

　　1. 当 wait 是 False 时，如果 l 没有上锁，那么acquire()调用将l上锁，然后返回True；

　　2. 当 wait 是 False 时，如果 l 已经上锁，那么acquire()调用对 l 没有影响，然后返回False；

　　3. 当 wait 是 True 时，如果 l 没有上锁，acquire()调用将其上锁，然后返回True；

　　4. 当 wait 是 True 时，如果 l 已经上锁，此时调用 l.acquire() 的线程将会阻塞，直到其他线程调用 l.release()，这里需要注意的是，就算这个线程是最后一个锁住 l 的线程，只要它以wait=True调用了acquire()，那它就会阻塞，因为Lock原语是不支持重入的。

　　可将，只要 l 没有上锁，调用 acquire()的结果是相同的。当l 上锁了，而 wait=False 时，线程会立即得到一个返回值，不会阻塞在等待锁上面；而 wait = True时，线程会阻塞等待其他的线程释放该锁，所以，一个锁上面可能有多个处于阻塞等待状态的线程。

 

1	l.locked()

　　判断 l 当前是否上锁，如果上锁，返回True，否则返回False。

 

1	l.release()

　　解开 l 上的锁，要求：

• 任何线程都可以解开一个已经锁上的Lock对象；
• l 此时必须处于上锁的状态，如果试图 release() 一个 unlocked 的锁，将抛出异常 thread.error。

　　l一旦通过release()解开，之前等待它（调用过 l.acquire()）的所有线程中，只有一个会被立即被唤醒，然后获得这个锁。

2. RLock 可重入锁

2.1 RLock对象的创建

　　RLock是可重入锁，提供和lock对象相同的方法，可重入锁的特点是

• 　　记录锁住自己的线程 t ，这样 t 可以多次调用 acquire() 方法而不会被阻塞，比如 t 可以多次声明自己对某个资源的需求。
• 　　可重入锁必须由锁住自己的线程释放（rl.release()）
• 　　rlock内部有一个计数器，只有锁住自己的线程 t 调用的 release() 方法和之前调用 acquire() 方法的次数相同时，才会真正解锁一个rlock。

　　通过：

1	>>> rl = threading.RLock()

　　可以创建一个可重入锁。

2.2 rlock对象的方法

　　rlock()对象提供和Lock对象相同的acquire()和release()方法。

3. Condition 条件变量

3.1 Condition 对象的获取

　　condition对象封装了一个lock或rlock对象，通过实例化Condition类来获得一个condition对象：

1	c = threading.Condition(lock=None)

　　正如前面说的，condition对象的是基于Lock对象RLock对象的，如果创建 condition 对象时没传入 lock 对象，则会新创建一个RLock对象。

3.2 Condition 对象的方法

　　Condition对象封装在一个Lock或RLock对象之上，提供的方法有：acquire(wait=1)、release()、notify()、notifyAll()和wait(timeout=None)

1	c.acquire(wait=1)<br>c.release()

　　本质上， condition对象的 acquire() 方法和 release() 方法都是底层锁对象的对应方法，在调用condition对象的其他方法之前，都应该确保线程已经拿到了condition对象对应的锁，也就是调用过 acquire()。

1 2	c.notify() c.notify_all()

　　notify()唤醒一个等待 c 的线程，notify_all() 则会唤醒所有等待 c 的线程；

　　线程在调用 notify() 和 notifyAll() 之前必须已经获得 c 对应的锁，否则抛出 RuntimeError。

　　notify() 和 notifyAll() 并不会导致线程释放锁，但是notify() 和 notify_all()之后，唤醒了其他的等待线程，当前线程已经准备释放锁，因此线程通常会紧接着调用 release() 释放锁。

1	c.wait(timeout=None)

　　wait()最大的特点是调用wait()的线程必须已经acquire()了 c ，调用wait()将会使这个线程放弃 c，线程在此阻塞，然后当wait()返回时，这个线程往往又拿到了 c 。这个描述比较绕，看一个直观一点的：

　　一个线程想要对临界资源进行操作，首先要获得 c ，获得 c 后，它判断临界资源的状态对不对，发现不对，就调用 wait()放掉手中的 c ，这时候实际上就是在等其他的线程来更新临界资源的状态了。当某个其他的线程修改了临界资源的状态，然后唤醒等待 c 的线程，这时我们这个线程又拿到 c （假设很幸运地抢到了），就可以继续执行了。

　　如果临界资源一直不对，而我们这个线程又抢到了 c ，就可以通过一个循环，不断地释放掉不需要的锁，直到临界资源的状态符合我们的要求。

例如：

# 消费者 cv.acquire() while not an_item_is_available():     cv.wait() get_an_available_item() cv.release()   # 生产者 cv.acquire() make_an_item_available() cv.notify() cv.release()

　　这个例子中，消费者在产品没有被生产出来之前，就算拿到 c ，也会立即调用 wait() 释放，当产品被生产出来后，生产者唤醒一个消费者，消费者重新回到 wait() 阻塞的地方，发现产品已经就绪，于是消费产品，最后释放 c 。

4 Event 事件

4.1 Event 对象的创建

　　Event对象可以让任何数量的线程暂停和等待，event 对象对应一个 True 或 False 的状态（flag），刚创建的event对象的状态为False。通过实例化Event类来获得一个event对象：

1	e = threading.Event()

　　刚创建的event对象 e，它的状态为 False。

4.2 Event 对象的方法

1

e.clear()

　　将 e 的状态设置为 False。

1

e.set()

　　将 e 的状态设置为 True。

　　此时所有等待 e 的线程都被唤醒进入就绪状态。

1	e.is_set()

　　返回 e 的 状态——True 或 False。

1	e.wait(timeout=None)

　　如果 e 的状态为True，wait()立即返回True，否则线程会阻塞直到超时或者其他的线程调用了e.set()。

5. Semaphore 信号量

5.1 Semaphore 对象的创建

　　信号量无疑是线程同步中最常用的技术了，信号量是一类通用的锁，锁的状态通常就是真或假，但是信号量有一个初始值，这个值往往反映了固定的资源量。

　　通过调用：

1	s = threading.Semaphore(n=1)

　　创建一个Python信号量对象，参数 n 指定了信号量的初值。

5.2 Semaphore对象的方法

1	s.acquire(wait=True)

• 当 s 的值 > 0 时，acquire() 会将它的值减 1，同时返回 True。
• 当 s 的值 = 0 时，需要根据参数 wait 的值进行判断：如果wait为True，acquire() 会阻塞调用它的线程，直到有其他的线程调用 release() 为止；如果wait为False，acquire() 会立即返回False，告诉调用自己的线程，当前没有可用的资源。

1	s.release()

• 当 s 的值 > 0 时，release()会直接将 s 的值加一；
• 当 s 的值 = 0 时而当前没有其他等待的线程时，release() 也会将 s 的值加一；
• 当 s 的值 = 0 时而当前有其他等待的线程时，release() 不改变 s 的值（还是0），唤醒任意一个等待信号量的线程；调用release()的线程继续正常执行。

 

Queue模块

Queue模块支持先进先出（FIFO）队列，支持多线程的访问，包括一个主要的类型（Queue）和两个异常类（exception classes）。

　　Python 2 中的Queue模块在Python 3中更名为 queue。

 

Queue对象的创建

　　可以通过实例化Queue类型获得队列对象：

1	q = Queue.Queue(maxsize=0)

　　创建新的队列，参数 maxsize 的含义是：

• 如果 maxsize > 0：当 q 中的元素达到 maxsize 个时，队列就满了，此时再有一个线程希望向里面插入时，如果指定了 block 选项，就会阻塞直到一个线程从里面抽出一个元素。
• 如果 maxsize <= 0：Python会认为这是一个没有容量限制的队列。

Queue模块定义的异常类

1	Queue.Empty

　　如果队列 q 是空的，此时又调用了 q.get(False)，就会抛出该异常。

1	Queue.Full

　　如果队列q是满的，而又调用了 q.put(x, False)，就会抛出该异常。

Queue对象的方法

q.empty()

 　　判断队列是否为空。

q.full()

 　　判断队列是否已满。

q.get(block=True, timeout=None)
q.get_nowait()

　　参数 block 为 False 时，参数 timeout 没有意义，因为线程不会阻塞：

• 如果队列不为空，取走并返回该元素；
• 如果队列为空，抛出Queue.Empty

　　block 为 True 时，结合超时 timeout 判断当队列空时，是一直阻塞进程，还是进程阻塞一段时间。

　　get_nowait()等于get(False)，或者get(timeout=0)即不论队列空否，都不阻塞等待。

例如：

try:     x = q.get_nowait() except Queue.Empty:     print "no more items to process"

q.put(item, block=True, timeout=None)
q.put_nowait(item)

　　向队列中插入 item，如果队列满了，抛出Queue.Full或线程阻塞等待。

q.qsize()

　　返回当前队列中的元素个数。

q.join()

q.task_done()