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

            #
            !/usr/bin/env python
            
#
             -*- coding:utf-8 -*-
            """
            从Thread类中派生出一个子例，创建一个这个子类的实例
            """
            import
             threading

            from time import sleep, ctime

loops = (4, 2)


class MyThread(threading.Thread):
    """
    1.子类化Thread类
    2.要先调用基类的构造器，进行显式覆盖
    3.重新定义run()函数
    """def__init__(self, func, args, name=‘‘):
        super(MyThread, self).__init__()
        self.name = name
        self.func = func
        self.args = args

    def run(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 = MyThread(loop, (i, loops[i]), loop.__name__)  # 创建子类的实例        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()

            #
            !/usr/bin/env python
            
#
             -*- coding:utf-8 -*-
            """
            
1.单独化子类，让Thread的子类更加通用。
2.加上getResult()函数译返回函数的运行结果。


            """
            import
             threading

            from time import ctime


class MyThread(threading.Thread):
    def__init__(self, func, args, name=‘‘):
        threading.Thread.__init__(self)
        self.name = name
        self.func = func
        self.args = args

    def getResult(self):
        return self.res

    def run(self):
        print‘starting‘, self.name, ‘at:‘, ctime()
        self.res = apply(self.func, self.args)
        print self.name, ‘finished at:‘, ctime()

            #
            !/usr/bin/env python
            
#
             -*- coding:utf-8 -*-
            from myThread import MyThread
from time import ctime, sleep


def fib(x):
    """求斐波那契数列之和"""
    sleep(0.005)
    if x < 2:
        return 1
    return fib(x-2) + fib(x-1)


def fac(x):
    """求阶乘"""
    sleep(0.1)
    if x < 2:
        return 1
    return x * fac(x-1)


def sum_(x):
    """自然数累加和"""
    sleep(0.1)
    if x < 2:
        return 1
    return x + sum_(x-1)

funcs = [fib, fac, sum_]  # 将三个函数放到列表中
n = 12


def main():
    nfuncs = range(len(funcs))  # nfuncs = range(3)print‘*** SINGLE THREAD‘# 单线程计算三个函数for i in nfuncs:
        print‘staring‘, funcs[i].__name__, ‘at:‘, ctime()  # 打印出函数名称，开始运行时间print funcs[i](n)  # 打印计算结果print funcs[i].__name__, ‘finished at:‘, ctime()  # 打印出函数名称，结束运行时间print‘\n*** MULTIPLE THREADS‘# 多线程计算三个函数
    threads = []
    for i in nfuncs:
        t = MyThread(funcs[i], (n,), funcs[i].__name__)  # 实例化三个MyThread对象
        threads.append(t)  # 将三个对象放到列表中for i in nfuncs:
        threads[i].start()  # 启动三个线程for i in nfuncs:
        threads[i].join()  # join()会等到线程结束或超时，即允许主线程等待线程结束print threads[i].getResult()  # 调用对象的getResult()方法print‘all DONE‘if__name__ == ‘__main__‘:  # 独立运行脚本，即在此脚本在直接运行时，才会调用main()函数
    main()

            #
            !/usr/bin/env python
            
#
             -*- coding: utf8 -*-
            from random import randint  # randint随机进行生产和消耗from time import sleep
from Queue import Queue
from myThread import MyThread


def writeQ(queue):
    print‘producing object for Q...‘, queue.put(‘xxx‘, 1)  # 把xxx对象放进队列中，并等待队列中有空间为止print"size now", queue.qsize()  # 返回队列大小def readQ(queue):
    val = queue.get(1)  # 从队列中取出一个对象（消耗）print‘consumed object form Q... size now‘, queue.qsize()  # 返回队列大小def writer(queue, loops):
    """一次往队列中放进一个对象，等待一会，然后再做给定次数的相同的事"""for i in range(loops):
        writeQ(queue)  # 调用writeQ,放进一个对象
        sleep(randint(1, 3))  # 随机睡眠1~3秒def reader(queue, loops):
    """一次从队列中取出一个对象，等待一会，然后做给定次数的相同的事"""for i in range(loops):
        readQ(queue)
        sleep(randint(2, 5))  # 睡眠时间比 write 中的长，以使 reader 在取数据的时候能够拿到数据
funcs = [writer, reader]
nfuncs = range(len(funcs))


def main():
    nloops = randint(2, 5)
    q = Queue(32)  # 创建一个大小为32的对象，和 q 绑定
    threads = []
    for i in nfuncs:
        t = MyThread(funcs[i], (q, nloops), funcs[i].__name__)  # 实例化 writer, reader 这两个对象
        threads.append(t)  # 放入空列表中for i in nfuncs:
        threads[i].start()  # 启动线程for i in nfuncs:
        threads[i].join()  # join()会等到线程结束或超时，即允许主线程等待线程结束print‘all DONE‘if__name__ == ‘__main__‘:  # 独立运行脚本
    main()