《Python核心编程》18.多线程编程（二）

18.1没有线程支持

#!/usr/bin/env python
# -*- coding:utf-8 -*-
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 'staring at:', ctime()
    loop0()
    loop1()
    print 'all DONE at:', ctime()

if __name__ == '__main__':
    main()

18.2thread线程支持

#!/usr/bin/env python
# -*- coding:utf-8 -*-
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, ())
    # 函数start_new_thread()产生一个新线程来运行函数loop0()

    thread.start_new_thread(loop1, ())
    # 同上，两个线程同同时运行

    sleep(6)  # 主线程睡眠等待；如果主线程（此程序本身）没有停下来，就会直接运行下一条语句，不会等待两个线程运行完毕
    print 'all DONE at: ', ctime()

if __name__ == '__main__':
    main()

18.3 使用线程和锁

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import thread
from time import sleep, ctime

loops = [4, 2]
# 1储存每个循环的睡眠时间
# 2间接说明了循环的个数


def loop(nloop, nsec, lock):
    """记录循环的号码和睡眠时间，并添加锁"""
    print 'start loop', nloop, 'at:', ctime()
    sleep(nsec)
    print 'loop', nloop, 'done at:', ctime()
    lock.release()  # 当sleep()时间结束，释放锁用以通知主线程，此子线程已结束


def main():
    """包含三个循环：创建锁；创建线程并分配锁；线程结束并解锁"""
    print 'Starting at:', ctime()
    locks = []
    nloops = range(len(loops))  # 利用列表元素个数说明循环次数

    for i in nloops:
        lock = thread.allocate_lock()  # 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()

18.4使用threaging 模块

#!usr/bin/env python
# -*- coding:utf-8 -*-

"""创建一个Thread（threading模块中的类）的实例，传给它一个函数"""


import threading
from time import sleep, ctime

loops = [4, 2]
# 1储存每个循环的睡眠时间
# 2间接说明了循环的个数


def loop(nloop, nsec):
    """1记录循环的号码 2记录睡眠时间"""
    print 'start loop', nloop, 'at:', ctime()
    sleep(nsec)
    print 'loop', nloop, 'done at:', ctime()


def main():
    print 'starting at:',  ctime()
    threads = []
    nloops = range(len(loops))  # 记录循环次数

    for i in nloops:
        t = threading.Thread(target=loop, args=(i, loops[i]))
        # 1实例化Thread类对象，将函数（target）和参数（args）传入，得到返回的Thread实例：线程对象t。
        # 2实例化（调用）Thread类时，不会像thread.star_new_thread那样，线程立即开始，这样可以更好的同步。
        threads.append(t)  # 创建对象列表

    for i in nloops:
        threads[i].start()  # 开始线程的执行

    for i in nloops:
        threads[i].join()
        # 1调用join()方法后，主线程会等到线程结束才执行下条语句，相比使用等待锁释放的无线循环（自旋锁）更为清楚。
        # 2若主线程除了等待线程结束外，还有其他事情要做（如处理或等待其他的客户请求），就不用调用join()。主线程
        #  依然会等待线程执行完毕。

    print 'all DONE at:', ctime()

if __name__ == '__main__':
    main()

18.5使用threading模块

#!/usr/bin/env python
# -*- coding:utf-8 -*-

"""创建一个Thread实例，传给它一个可调用的类对象"""


import threading
from time import sleep, ctime

loops = [4, 2]
# 1储存每个列表的循环时间
# 2间接说明循环的个数


class ThreadFunc(object):
    """
    想让这个类在调用函数方面尽量地通用，并不局限与loop()函数。
    这个类保存了函数本身，函数的参数，以及函数名字的字符串。
    构造函数__init__()中做了这些值的赋值操作。
    """

    def __init__(self, func, args, name=''):
        super(ThreadFunc, self).__init__()
        self.name = name
        self.func = func
        self.args = args

    def __call__(self):  # 用来执行类中的函数
        self.func(*self.args)


def loop(nloop, nsec):
    print 'start loop', nloop, 'at:', ctime()
    sleep(nsec)
    print 'loop', nloop, 'done at:', ctime()


def main():
    print 'starting at:', ctime()
    threads = []
    nloops = range(len(loops))

    for i in nloops:
        t = threading.Thread(target=ThreadFunc(loop, (i, loops[i]), loop.__name__))
        # 1.实例化Thread对象时，同时也会实例化ThreadFunction对象，即实例化了两个对象
        # 2.由于已经有了要用的参数，就不用额外添加参数到Thread()的构造器中
        # 3.这里时传送类对象，而18.4中传送的是函数

        threads.append(t)

    for i in nloops:
        threads[i].start()

    for i in nloops:
        threads[i].join()

    print 'all DONE at:', ctime()

if __name__ == '__main__':
    main()