Python多线程

首先看一个简单的没有线程支持的情况下的顺序执行:


<span style="font-size:18px;">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(4)
    print('loop 1 done at:', ctime())


def main():
    print('starting at:', ctime())
    loop0()
    loop1()
    print('all DONE at:', ctime())


if __name__ == '__main__':
    main()</span>
在这个程序中,loop0 先执行,loop1后执行,其结果如下所示:



如果想要并行执行,需加入threading模块的支持,模块的对象有如下几个:



模块中的主要函数有:


  • 是你主要的线程类,可以创建进程实例。该类提供的函数包括:
  • getName(self) 返回线程的名字
  • isAlive(self) 布尔标志,表示这个线程是否还在运行中
  • isDaemon(self) 返回线程的daemon标志
  • join(self, timeout=None) 程序挂起,直到线程结束,如果给出timeout,则最多阻塞timeout秒
  • run(self) 定义线程的功能函数
  • setDaemon(self, daemonic) 把线程的daemon标志设为daemonic
  • setName(self, name) 设置线程的名字
  • start(self) 开始线程执行
示例如下:

<span style="font-size:18px;">import threading
from time import sleep, ctime

loops = [ 4, 2 ]

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=loop,
	    args=(i, loops[i]))
        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()</span>

在本例中,启动loop0线程和loop1线程,并发执行,执行结果如图:


通过观察执行结果可看到,41-43秒loop0和loop1都在执行,其中loop1从41秒执行到43共2秒,loop0从41到45共4秒。

为了使程序更有面向对象的概念,在下个程序中增加了ThreadFunc类和创建Thread对象时实例化一个可调用的ThreadFunc的类对象,代码如下:

<span style="font-size:18px;">import threading
from time import sleep, ctime

loops = [ 4, 2 ]

class ThreadFunc(object):

    def __init__(self, func, args, name=''):
        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:	# create all threads
        t = threading.Thread(
	    target=ThreadFunc(loop, (i, loops[i]),
	    loop.__name__))
        threads.append(t)

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

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

    print('all DONE at:', ctime())


if __name__ == '__main__':
    main()</span>

这样通过传入一个可以调用的类的实例,而不仅仅是传入一个函数,更具面向对象的概念,运行结果如下:



下面通过一个计算斐波那契、阶乘、累加和三个函数在单线程和多线程中运行来说明多线程的好处。

我们现在要子类化Thread类,以更加灵活的定制线程对象。

myThread子类模块如下:

<span style="font-size:18px;">import threading
from time import time, 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 =  self.func(*self.args)
        print(self.name, 'finished at:',
              ctime())</span>

主程序模块如下:

<span style="font-size:18px;">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))

    print('*** SINGLE THREAD')
    for i in nfuncs:
        print('starting', 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__)
        threads.append(t)

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

    for i in nfuncs:
        threads[i].join()
        print(threads[i].getResult())

    print('all DONE')


if __name__ == '__main__':
    main()</span>

程序运行结果如下:



参考资料:《Python核心编程》

实例代码下载:https://github.com/wlseu/pythread






评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值