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()

實際上多線程花的時間就是計算最慢的那個函數所花的時間。