Python 多线程

在CPython中，由于全局解释器锁的存在，一次只有一个线程可以执行Python代码（即使某些性能为导向的库可以克服这个限制）。如果你希望你的应用程序更好地使用多核机器的计算资源，建议你使用multiprocessing。然而，如果你想并发地运行多个I/O密集的任务，threading仍然是一个合适的模型。

threading常用方法：
threading.currentThread(): 返回当前的线程变量。
threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

threading模块提供的类：
Thread, Lock, Rlock, Condition, [Bounded]Semaphore, Event, Timer, local.

Thread是线程类，与Java类似，有两种使用方法，直接传入要运行的方法或从Thread继承并覆盖run()：

threading实现线程的两种方法：
方法一：

将要执行的方法作为参数传给Thread的构造方法
def func():
print 'func() passed to Thread'

t = threading.Thread(target=func)
t.start()

Thread(group=None, target=None, name=None, args=(), kwargs={})
group: 线程组，目前还没有实现，库引用中提示必须是None；
target: 要执行的方法；
name: 线程名；
args/kwargs: 要传入方法的参数。

方法二：

从Thread继承，并重写run()
class MyThread(threading.Thread):
def run(self):
print 'MyThread extended from Thread'

t = MyThread()
t.start()

Thread类提供以下实例方法：
isAlive(): 返回线程是否在运行。正在运行指启动后、终止前。
get/setName(name): 获取/设置线程名。
is/setDaemon(True/Flase): 获取/设置是否守护线程。初始值从创建该线程的线程继承。当没有非守护线程仍在运 行时，程序将终止。
start(): 启动线程。
join([timeout]): 阻塞当前上下文环境的线程，直到调用此方法的线程终止或到达指定的timeout（可选参数）。
getName():返回线程名
setName():设置线程名

使用 thread 模块创建线程

函数式： 调用 thread 模块中的 start_new_thread() 函数来产生新线程。语法如下:

thread.start_new_thread( function, args[, kwargs] )

function - 线程函数。
args - 传递给线程函数的参数，他必须是个 tuple 类型。
kwargs - 可选参数。

线程同步

如果多个线程共同对某个数据修改，则可能出现不可预料的结果，为了保证数据的正确性，需要对多个线程进行同步。

使用 Thread 对象的 Lock 和 Rlock 可以实现简单的线程同步，这两个对象都有 acquire 方法和 release 方法，对于那些需要每次只允许一个线程操作的数据，可以将其操作放到 acquire 和 release 方法之间。

Lock（指令锁）是可用的最低级的同步指令。Lock 处于锁定状态时，不被特定的线程拥有。Lock 包含两种状态——锁定和非锁定，以及两个基本的方法。

可以认为 Lock 有一个锁定池，当线程请求锁定时，将线程至于池中，直到获得锁定后出池。池中的线程处于状态图中的同步阻塞状态。

构造方法：

Lock()
实例方法：

acquire([timeout])：使线程进入同步阻塞状态，尝试获得锁定。
release()：释放锁。使用前线程必须已获得锁定，否则将抛出异常。
RLock（可重入锁）是一个可以被同一个线程请求多次的同步指令。RLock 使用了拥有的线程和递归等级的概念，处 于锁定状态时，RLock 被某个线程拥有。拥有RLock的线程可以再次调用acquire()，释放锁时需要调用 release() 相同次数。

可以认为 RLock 包含一个锁定池和一个初始值为0的计数器，每次成功调用 acquire()/release()，计数器将 +1/-1，为0时锁处于未锁定状态。

例子3：

# -* - coding: UTF-8 -* -

#!/usr/bin/python

from threading import Thread,Lock
import time

threadLock = Lock()

class myThread (Thread):
def __init__(self, name, delay):
Thread.__init__(self)
self.name = name
self.delay = delay

def run(self):
print "Starting " + self.name
# 获得锁，成功获得锁定后返回True
# 可选的timeout参数不填时将一直阻塞直到获得锁定
# 否则超时后将返回False
threadLock.acquire()
print_time(self.name, self.delay, 3)
# 释放锁
threadLock.release()

def print_time(threadName, delay, counter):
while counter:
time.sleep(delay)
print "%s: %s" % (threadName, time.ctime(time.time()))
counter -= 1

# 创建新线程
thread1 = myThread( "Thread-1", 1)
thread2 = myThread("Thread-2", 2)

# 开启新线程
thread1.start()
thread2.start()

# 等待所有线程完成
thread1.join()
thread2.join()

print "Exiting Main Thread"
运行结果：

Starting Thread-1
Starting Thread-2
Thread-1: Tue Dec 23 16:06:32 2014
Thread-1: Tue Dec 23 16:06:33 2014
Thread-1: Tue Dec 23 16:06:34 2014
Thread-2: Tue Dec 23 16:06:36 2014
Thread-2: Tue Dec 23 16:06:38 2014
Thread-2: Tue Dec 23 16:06:40 2014
Exiting Main Thread

例子3和例子2的区别在于，例子上中 print_time 方法前后添加了 threadLock 的两个方法，并且在主线程调用了两个线程的 join 方法，
使得主线程阻塞直到两个子线程运行完成。待子线程运行完成之后，最后才会打印 Exiting Main Thread ，即表示主线程运行完成。

除了使用 Lock 类获取锁之外，我们还可以使用 Condition 类，condition 的 acquire() 和 release() 方法内部调用了 lock 的 acquire() 和 release()，所以我们可以用 condiction 实例取代 lock 实例，但 lock 的行为不会改变。

线程优先级队列

Python 的 Queue 模块中提供了同步的、线程安全的队列类，包括 FIFO（先入先出)队列 Queue，LIFO（后入先出）队列 LifoQueue，和优先级队列 PriorityQueue。这些队列都实现了锁原语，能够在多线程中直接使用。可以使用队列来实现线程间的同步。

Queue模块中的常用方法:

Queue.qsize()：返回队列的大小
Queue.empty()：如果队列为空，返回 True，反之 False
Queue.full()：如果队列满了，返回 True，反之 False
Queue.full：与 maxsize 大小对应
Queue.get([block[, timeout]])：获取队列，timeout 等待时间
Queue.get_nowait()：相当 Queue.get(False)
Queue.put(item)：写入队列，timeout 等待时间
Queue.put_nowait(item)：相当 Queue.put(item, False)
Queue.task_done()：在完成一项工作之后，Queue.task_done() 函数向任务已经完成的队列发送一个信号
Queue.join()：实际上意味着等到队列为空，再执行别的操作
实例4：

# -* - coding: UTF-8 -* -

#!/usr/bin/python

from threading import Thread,Lock
import Queue
import time

threadList = ["Thread-1", "Thread-2", "Thread-3"]
nameList = ["One", "Two", "Three", "Four", "Five"]
workQueue = Queue.Queue(10)
queueLock = Lock()
threads = []
exitFlag = 0

class myThread (Thread):
def __init__(self, name, q):
Thread.__init__(self)
self.name = name
self.q = q

def run(self):
print "Starting " + self.name
process_data(self.name, self.q)
print "Exiting " + self.name

def process_data(threadName, q):
while not exitFlag:
queueLock.acquire()
if not workQueue.empty():
data = q.get()
queueLock.release()
print "%s processing %s" % (threadName, data)
else:
queueLock.release()
time.sleep(1)

# 创建新线程
for tName in threadList:
thread = myThread(tName, workQueue)
thread.start()
threads.append(thread)

# 填充队列
queueLock.acquire()
for word in nameList:
workQueue.put(word)
queueLock.release()

# 等待队列清空
while not workQueue.empty():
pass

# 通知线程是时候退出
exitFlag = 1

# 等待所有线程完成
for t in threads:
t.join()
print "Exiting Main Thread"
例子4中创建了3个线程读取队列的数据，当队列为空时候，三个线程停止运行，另外主线程会一直阻塞直到三个子线程运行完毕，最后再打印 "Exiting Main Thread"。

 

python queue模块有三种队列:
1、python queue模块的FIFO队列先进先出。
2、LIFO类似于堆。即先进后出。
3、还有一种是优先级队列级别越低越先出来。

针对这三种队列分别有三个构造函数:
1、class Queue.Queue(maxsize) FIFO
2、class Queue.LifoQueue(maxsize) LIFO
3、class Queue.PriorityQueue(maxsize) 优先级队列

介绍一下此包中的常用方法:

Queue.qsize() 返回队列的大小
Queue.empty() 如果队列为空，返回True,反之False
Queue.full() 如果队列满了，返回True,反之False
Queue.full 与 maxsize 大小对应
Queue.get([block[, timeout]])获取队列，timeout等待时间
Queue.get_nowait() 相当Queue.get(False)
非阻塞 Queue.put(item) 写入队列，timeout等待时间
Queue.put_nowait(item) 相当Queue.put(item, False)
Queue.task_done() 在完成一项工作之后，Queue.task_done()函数向任务已经完成的队列发送一个信号
Queue.join() 实际上意味着等到队列为空，再执行别的操作