thread模块除了提供派生线程外，thread模块还提供了基本的同步数据结构，成为锁对象（也叫原语锁、简单锁、互斥锁、二进制信号量），这个同步原语和线程管理密切相关的。
thread 模块的核心函数是start_new_thread()它的参数包括函数（对象）、函数的参数以及可选的关键字参数。将专门派生新的线程来调用这个参数。把多线程整合进上一节的代码例子中。把对loop*()函数的调用稍微改变一下。得到示例中的mtsleepA.py文件。
import thread
from time import sleep , ctime
def loop0():
print 'start loop 0 at:', ctime()
sleep(4)
print 'loop 0 done at:', ctime()
def loop1():
print 'start loop 1 at:', ctime()
sleep(2)
print 'loop 1 done at:', ctime()
def main():
print 'starting at:', ctime()
thread.start_new_thread(loop0, () )
thread.start_new_thread(loop1, () )
sleep(6)
print('all DONE at:', ctime() )
if __name__ == '__main()__':
main()
start_new_thread()必须包含开始的两个参数，于是即使要执行的函数不需要参数，也需要传递一个空元组。
与之前的代码相比，本程序执行后的输出结果有很大的不同。原来的程序运行需要6~7秒的时间，而现在的脚本只需要运行4秒，也就是最长的循环加上其他所有的开销的时候之和。
starting at: Tue Jan 23 20:49:50 2018
start loop 0 at: Tue Jan 23 20:49:50 2018
start loop 1 at: Tue Jan 23 20:49:50 2018
loop 1 done at: Tue Jan 23 20:49:52 2018
loop 0 done at: Tue Jan 23 20:49:54 2018
all DONE at: Tue Jan 23 20:49:56 2018
睡眠 4 秒和睡眠 2 秒的代码片段是并发执行的，这样有助于减少整体的运行时间。你甚至可以看到loop1是如何在loop0之前结束的。
这个应用程序中剩下的一个主要区别是增加了sleep(6)调用。为什么这个做呢？因为如果我们没有阻止主线程继续执行，它将会执行下一条语句，显示all DONE at: XXX 然后退出，而loop0()和loop1这两个线程将中止执行。
我们没有写让主线程等待子线程全部完成后再继续的代码，即我们所说的线程需要某种形式的同步，在这个例子中，调用sleep()来作为同步机制。将其设定为6秒是因为我们知道所有线程（用时 4 秒和用时 2 秒的）会在主线程计时到6秒前完成。
你可能会想到肯定会有比主线程中额外延时 6 秒更好的方法管理线程。由于这个延时使整个代码没有比单线程的版本执行的更快。想这个使用sleep()来进行线程同步是不可靠的。如果循环有独立且执行不同的时间要怎么办呢？我们可能会过早或过晚退出主线程，这就是我们引出锁的原因。
再一次修改代码，引入锁，并去除单独的循环函数，修改后的代码为 mtsleepB.py 如下所示。
import thread
from time import sleep , ctime
loops = [4,2]
def loop(nloop, nsec, lock):
print 'start loop' , nloop, 'at:', ctime()
sleep(nsec)
print 'loop' , nloop , 'done at:', ctime()
lock.release()
def main():
print 'starting at:' , ctime()
locks = []
nloops = range(len(loops))
for i in nloops:
lock = thread.allocate_lock()
lock.acquire()
locks.append(lock)
for i in nloops:
thread.start_new_thread(loop, (i , loops[i], locks[i]))
for i in nloops:
while locks[i].locked():
pass
print 'all DONE at:' , ctime()
if __name__ == '__main__':
main()
执行结果如下：
starting at: Tue Jan 23 21:32:00 2018
start loop 0 at: Tue Jan 23 21:32:00 2018
start loop 1 at: Tue Jan 23 21:32:00 2018
loop 1 done at: Tue Jan 23 21:32:02 2018
loop 0 done at: Tue Jan 23 21:32:04 2018
all DONE at: Tue Jan 23 21:32:04 2018
我们可以看到输出结果与mtsleepA.py 相似。唯一的区别是我们不需要再像mtsleepA.py 那样等待额外的时间后才能结束。通过使用锁，我们可以在所有线程全部完成执行后立即退出。
代码解析：
大部分的工作是在
main()中完成的，这里使用了3个独立的for循环。首先创建一个锁的列表，通过使用thread.allocate_lock()函数得到锁对象，然后通过acquire()方法取得（每个锁）。取得锁效果相当于‘把锁锁上’。一旦锁被锁上后，就可以把它添加到锁列表lock()中。下一个循环用于派生线程，每个线程会调用loop()函数，并传递循环号、睡眠时间以及用于该线程的锁的这几个参数。那么为什么我们不在上锁的循环中启动线程呢？这里有两个原因：其一，我们想要同步线程，以便“所有的马同时冲出围栏”；其二，获取锁需要花费一点时间，如果线程执行的太快，可能出现获取锁之前线程就执行结束的情况。
在每个线程执行完成时，它会释放自己的锁对象。最后一个循环只是坐在那里等待（暂停主线程），直到所有锁都被释放之后才会继续执行。因为我们按照顺序检查每个锁，所有可能会被排在循环列表前面但是执行的较慢的循环拖累。在这种情况下，大部分时间实在等待最前面的线程。当这种线程的锁被释放时，剩下的锁可能早已被释放（也就是说，对应的线程以及执行完毕）。结果就是主线程会飞快地、没有停顿地完成剩下锁的检查。最后，你应该知道我们直接待用这个脚本时，最后几行语句才会执行main()函数。
