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()