Python的并发并行[1] -> 线程[1] -> 多线程的建立与使用

多线程的建立与使用

---

目录

1. 生成线程的三种方法
2. 单线程与多线程对比
3. 守护线程的设置

1 生成线程的三种方法

三种方式分别为:

1. 创建一个Thread实例，传给它一个函数
2. 创建一个Thread实例，传给它一个可调用的类实例
3. 派生Thread的子类，并创建子类的实例

# There are three ways to create a thread
# The first is create a thread instance, and pass a function
# The second one is create a thread instance, and pass the callable instance(obj)
# The third one is create a subclass of Thread, then generate an instance

1.1 创建Thread实例并传递一个函数

在Thread类实例化时，将函数（及其参数）传入，下面的例子中，在实例化Thread类的时候传入了一个函数loop及其参数，生成了一个线程的实例，再启动线程。

# Method one: pass function
from threading import Thread
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))

    # Create all threads
    for i in nloops:
        t = Thread(target=loop, args=(i, loops[i]))
        threads.append(t)
    for i in threads:
        i.start()
    for i in threads:
        i.join()
    print('All DONE at:', ctime())
    
if __name__ == '__main__':
    main()

1.2 创建Thread实例并传递一个可调用的类实例

同样，在Thread类实例化时，类（及其参数）传入，下面的例子中，在实例化Thread类的时候传入了一个可调用(__call__函数使类变为可调用)的类实例ThreadFunc，且完成初始化传给target=，此时生成了一个线程的实例，随后启动线程。

# Method two: pass object

from threading import Thread
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))

    # Create all threads
    for i in nloops:
        t = Thread(target=ThreadFunc(loop, (i, loops[i]), loop.__name__))
        threads.append(t)
    for i in threads:
        i.start()
    for i in threads:
        i.join()
    print('All DONE at:', ctime())
    
if __name__ == '__main__':
    main()

1.3 派生Thread子类并生成子类实例

以Thread为基类，派生出一个子类，在子类中重定义run方法，最终生成一个线程实例进行调用。下面的例子中，生成了一个子类MyThread，同时重定义run函数，在初始化时接收一个func参数作为调用函数。

# Method three: by subclass

from threading import Thread
from time import sleep, ctime

loops = [4, 2]

class MyThread(Thread):
    def __init__(self, func, args, name=''):
        Thread.__init__(self)
        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))

    # Create all threads
    for i in nloops:
        t = MyThread(loop, (i, loops[i]), loop.__name__)
        threads.append(t)
    for i in threads:
        i.start()
    for i in threads:
        i.join()
    print('All DONE at:', ctime())
    
if __name__ == '__main__':
    main()

2 单线程与多线程对比

利用单线程与多线程分别进行斐波那契，阶乘与累加操作，此处加入了sleep进行计算延迟，这是由于Python解释器的GIL特性使得Python对于计算密集型的函数并没有优势，而对于I/O密集型的函数则优化性能较好。

from threading import Thread
import time
from time import ctime


class MyThread(Thread):
    """
    Bulid up a Module to make this subclass more general
    And get return value by add a function named 'getResult()'
    """
    def __init__(self, func, args, name=''):
        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())
        # Call function here and calculate the running time
        self.res = self.func(*self.args)
        print(self.name, 'finished at:', ctime())

def fib(x):
    time.sleep(0.005)
    if x < 2:
        return 1
    return (fib(x-2) + fib(x-1))

def fac(x):
    time.sleep(0.1)
    if x < 2:
        return 1
    return (x * fac(x-1))

def sumx(x):
    time.sleep(0.1)
    if x < 2:
        return 1
    return (x + sumx(x-1))

funcs = [fib, fac, sumx]
n = 12

def main():
    nfuncs = range(len(funcs))
    print('***SINGLE THREADS')
    for i in nfuncs:
        print('Starting', funcs[i].__name__, 'at:', ctime())
        print(funcs[i](n))
        print(funcs[i].__name__, 'finished at:', ctime())

    print('
***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()

第 1-24 行，导入所需模块，并派生线程的子类，定义一个返回函数用于返回结果，

第 26-45 行，分别定义斐波那契，阶乘与累加函数，

最后在主函数中分别运行两种模式的计算，得到结果

***SINGLE THREADS  
Starting fib at: Tue Aug  1 20:17:47 2017  
233  
fib finished at: Tue Aug  1 20:17:50 2017  
Starting fac at: Tue Aug  1 20:17:50 2017  
479001600  
fac finished at: Tue Aug  1 20:17:51 2017  
Starting sumx at: Tue Aug  1 20:17:51 2017  
78  
sumx finished at: Tue Aug  1 20:17:52 2017  
  
***MULTIPLE THREADS  
Starting fib at: Tue Aug  1 20:17:52 2017  
Starting fac at: Tue Aug  1 20:17:52 2017  
Starting sumx at: Tue Aug  1 20:17:52 2017  
sumx finished at: Tue Aug  1 20:17:53 2017  
fac finished at: Tue Aug  1 20:17:53 2017  
fib finished at: Tue Aug  1 20:17:54 2017  
233  
479001600  
78  
All DONE  

从结果中可以看出单线程耗时5秒，而多线程耗时2秒，优化了程序的运行速度。

Note: 再次注明，Python的多线程并未对计算性能有所提升，此处是由于加入了sleep的等待，因此使得Python的GIL发挥其优势。

3 守护线程的设置

守护线程一般属于后台无限循环的程序，主线程会在所有非守护线程结束之后，自动关闭还在运行的守护线程，而不会等待它的无限循环完成。守护线程的设置只要将线程实例的daemon设置为True即可，默认是False。

import threading
import time
import random

class MyThread(threading.Thread):
    def __init__(self, count):
        threading.Thread.__init__(self)
        print('%s: There are %d numbers need to be counted' % (self.name, count))
        self.count = count

    def run(self):
        name = self.name
        for i in range(0, self.count):
            print('%s counts %d' % (name, i))
            time.sleep(1)
        print('%s finished' % name)


def main():
    print('-------Starting-------')
    count = random.randint(4, 7)
    t_1 = MyThread(count*count)
    t_2 = MyThread(count)
    t_1.daemon = True
    t_2.daemon = False
    t_1.start()
    t_2.start()
    time.sleep(3)
    print('---Main Thread End---')

if __name__ == '__main__':
    main()
    

第 5-16 行，派生一个线程子类，run函数实现每秒计数一次的功能

第 19-29 行，在主函数中，分别生成两个线程实例，其中t_1计数量较大，设为守护线程，t_2计数量较小，设为非守护线程，线程均不挂起，主线程在3秒后会结束。

运行得到结果

-------Starting-------  
Thread-1: There are 36 numbers need to be counted  
Thread-2: There are 6 numbers need to be counted  
Thread-1 counts 0  
Thread-2 counts 0  
Thread-1 counts 1  
Thread-2 counts 1  
Thread-1 counts 2  
Thread-2 counts 2  
Thread-1 counts 3  
---Main Thread End---  
Thread-2 counts 3  
Thread-1 counts 4  
Thread-2 counts 4  
Thread-1 counts 5  
Thread-2 counts 5  
Thread-1 counts 6  
Thread-2 finished  

运行主函数后可以看到，两个线程启动后，计数3次时，主线程已经结束，而这时由于t_2是非守护线程，因此主线程挂起等待t_2的计数结束之后，杀掉了还在运行的守护线程t_1，并且退出了主线程。

相关阅读

---

1. 基本概念

2. threading 模块

参考链接

---

《Python 核心编程 第3版》