python threading多线程计算

本文持续更新…

threading 模块

当前运行的线程

一个进程可以有多个线程，通过threading模块来实现多线程计算，下面显示当前线程名

import threading

def main():
    print(threading.current_thread().getName())

if __name__=='__main__':
    main()

上面结果显示的是：我们当前运行的是主线程mainthread. 现在我们增加一个新的线程。

import threading

print(threading.current_thread().getName())

def sum_func(a,b):
    t = threading.current_thread()
    print(t.getName())  #當前線程名
    print(sum([a,b]))
    

new_t = threading.Thread(target=sum_func,args=(1,2)) #新加一個線程
new_t.start()    #開始線程計算

默认名字是Thread-1,通过下面的程序可以改名字

new_t = threading.Thread(target=sum_func,args=(1,2),name='new-thread')改名为new-thread

这里有一个反常的现象： 通常而言，单线程计算会先计算完第一个才进入第二个，而当我们使用thread模块之后，会综合利用CPU性能同时计算多个函数。

import threading
import time

print(threading.current_thread().getName())

def sum_func(a,b):
    t = threading.current_thread()
    print(t.getName())  #當前線程名
    time.sleep(3)
    print(sum([a,b]))
    

new_t = threading.Thread(target=sum_func,args=(1,2),name='new-thread') #新加一個線程
new_t.start()    #開始線程計算

print('end thread')

分析一下上面的结果，我们发现，如果是单线程的话，应该是sum_func先计算完，也就是计算完new_t.start()之后才会进入print(‘end thread’)语句，而从输出结果看，这个print在sum([a,b])之前完成了。这说明不是按照常规顺序进行的，而是综合CPU性能多个一起计算了，从而print(‘end thread’)被先执行了。

例子

这里给一个稍微复杂的书上的例子，用于计算斐波那契数列，阶乘，和求和。第一种是使用单线程进行的，第二个是使用多线程进行的。我们的目的是对比它们所花的时间。

#!/usr/bin/env python

from time import ctime, sleep
import threading
from time import sleep, ctime

loops = [4, 2]


class MyThread(threading.Thread):
    def __init__(self, func, args, name='', verb=False):
        threading.Thread.__init__(self)
        self.name = name
        self.func = func
        self.args = args
        self.verb = verb

    def getResult(self):
        return self.res

    def run(self):
        if self.verb:
            print(('starting', self.name, 'at:', ctime()))
        self.res = self.func(*self.args)
        if self.verb:
            print((self.name, 'finished at:', ctime()))

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 = 13


def main():
    nfuncs = list(range(len(funcs)))

    print('*** SINGLE THREAD')
    print('starting single thread at:',ctime())
    for i in nfuncs:
        # print('starting', funcs[i].__name__, \
	    # 'at:', ctime())
        print(funcs[i](n))
        # print(funcs[i].__name__, 'finished at:', \
        #     ctime())
    print('end single thread at:',ctime())
    print('\n*** MULTIPLE THREADS')
    print('starting multiple threads at:',ctime())
    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('end multiple threads at:',ctime())
    print('all DONE')

if __name__ == '__main__':
    main()

实际上多线程花的时间就是计算最慢的那个函数所花的时间。