在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() 实际上意味着等到队列为空，再执行别的操作