python 多线程受制于Global Interpreter Lock(GIL)并不能充分利用多处理器，仅仅是多线程同步使用一个处理器，因此该模块适用于I/O为主的程序。
1. Thread对象
class threading.Thread(group=None, target=None, name=None, args=(), kwargs={})
使用上面函数创建一个新的Thread实例。
target：即线程的目标函数，线程启动时，run()方法将调用此函数。
name：线程的名字，是一个字符串；默认将创建一个“Thread-N”格式的唯一名称。
args：传递给target函数的参数元组；注意，必须是元组，因此注意仅有一个参数时的情况。
Thread实例t支持以下方法和属性：
（1） t.start()
通过在一个单独的控制线程中调用run()方法，启动线程。此方法只能调用一次。
（2） t.run()
线程启动时将调用此方法。默认情况，它将调用传递到构造函数中的target函数；除此之外，还可以在Thread子类中重新定义此方法。
（3） t.is_alive()
如果线程是活动的，返回True；否则返回False。
（4） t.name
线程名称，是一个属性。可以通过它更改或获得线程的名字。
（5） t.daemon
线程的布尔型后台标志，是一个属性。必须在调用t.start()之前设置该值。它表示该线程是否是以daemon的形式执行，它的初始值继承自创建它的线程，因此一般是False。
threading会在主线程执行完毕后，检查是否有daemon为False的子线程，如果有，主线程就wait，等待子线程结束，在等待期间，所有发送到主线程的信号也会被阻塞，因此Ctrl-C不起作用。如果子线程的daemon都是True，那么主线程执行完毕后不会等待，整个程序（包括主线程和子线程）立即结束。
因此，比较常用的方法，就是将子线程的daemon设为True,并且在主线程结束前轮寻检测。
（6） t.join([timeout])
等待线程t，直到t终止或出现超时为止。timeout是一个浮点数，用于指定以秒为单位的超时时间。线程不能够join自己，而且不能在t运行之前就调用t.join()
当一个线程调用t.join()等待时，也会出现上文提到的wait，无法接收信号，因此如果主线程调用t.join()，将导致Ctrl-C失效。
示例：
import threading
import time
def clock(interval):
print "this is subThread!"
time.sleep(interval)
t=theading.Thread(target=clock,args=(15,))
t.daemon=True
t.start()
while t.is_alive():
time.sleep(1)
下面的例子实现了同样的功能：
import threading
import time
class Clock(threading.Thread):
def __init__(self,interval):
threading.Thread.__init__(self)
self.daemon=True
self.interval=interval
def run(self):
print "this is subThread!"
time.sleep(self.interval)
t=Clock(15)
t.start()
while t.is_alive():
time.sleep(1)上面的方法将线程定义为类，并且定义自己的__init__()方法，并且必须像上面那样调用基类构造函数Thread.__init__()。除此之外，需要重写run()方法，作为线程的目标函数。除了run()方法之外，重写已经定义的其他方法会出现错误。
2. Timer对象
class threading.Timer(interval, function, args=[], kwargs={})
创建定时器对象，在过去interval秒时间后运行函数function。args提供传递给function的参数。在调用start()方法后会启动定时器。
Timer对象t具有以下方法：
（1） t.start()
启动定时器。提供给Timer()方法的函数function将在指定的interval之后执行。
（2） t.cancel()
如果function函数尚未执行，取消定时器。
示例：
import threading
def hello():
print "hello, world"
t = threading.Timer(10.0, hello)
t.start() # after 30 seconds, "hello, world" will be printed在等待function执行这段期间，Ctrl-C失效
3. Lock对象
最基本的同步锁，并不属于某一个特定的线程，也就是说，一个线程设定的锁可以由另一个线程进行解锁。
通过lock=threading.Lock()创建Lock实例：
（1） lock.acquire([blocking])
获取锁定，需要阻塞到锁定释放为止。
（2） lock.release()
释放一个锁定。当锁处于未锁定情况时，进行解锁会异常；允许其他进程解锁
4. RLock对象
同步锁，属于某一个特定的线程，也就是说，一个线程设定的锁仅能由该线程解锁；其他进程若试图解锁会引发异常。RLock允许在同一线程中被多次acquire，而Lock却不允许这种情况。注意：如果使用RLock，那么acquire和release必须成对出现，即调用了n次acquire，必须调用n次的release才能真正释放所占用的琐。这条是正确的，可以开两个线程试一下！
通过rlock=threading.RLock()创建RLock实例：
（1） rlock.acquire([blocking])
（2） rlock.release()
5. Semaphore对象
信号量是一个基于计数器的同步原语，每次调用acquire()方法时此计数器减1，每次调用release()方法时此计数器加1。如果计数器为0，acquire()方法将会阻塞，直到其他线程调用release()方法为止。
class threading.Semaphore([value])
创建一个新的信号量。value是计数器的初始值，如果省略此参数，计数器的值将被置1.
Semaphore实例s支持以下方法。
（1） s.acquire([blocking])
获取信号量。如果进入时内部计数器大于0，此方法将把它的值减1，然后立即返回。如果它的值为0，此方法将被阻塞，直到另一个线程调用release()方法为止。
（2） s.release()
通过将内部计数器的值加1来释放一个信号量。
（3） BoundedSemaphore([value])
创建一个新的信号机。它的工作方式与Semaphore完全相同，但是release()操作的次数不能超过acquire()操作的次数（Semaphore可能存在这样的隐患）
6. 实用工具函数
（1） threading.active_count()
返回当前活动的Thread对象数量，包括主线程
（2） threading.current_thread()
返回当前Thread对象，在线程内部调用。
（3） threading.enumerate()
返回当前活动的Thread对象列表
