Python多线程—threading模块

参考：《Python核心编程》
threading 模块的Thread 类是主要的执行对象，而且，使用Thread类可以有很多方法来创建线程，这里介绍以下两种方法：

• 创建 Thread 实例，传给它一个函数。
• 派生 Thread 的子类，并创建子类的实例。

如果是有面向对象接口需求的，第二种方法更加符合。

1、创建Thread的实例，传给它一个函数

示例代码:

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("nloop ", nloop, " done at ", ctime())

def main():
    threads = []
    print("starting at: ", ctime())
    # create all threads
    for i in range(len(loops)):
        t = Thread(target=loop, args=(i, loops[i]))
        threads.append(t)
    # start thread
    for i in range(len(loops)):
        threads[i].start()
    # wait for all threads to finish
    for i in range(len(loops)):
        threads[i].join()
    print("all DONE at: ", ctime())

if __name__ == "__main__":
    main()

执行脚本：

$ python myThread.py 
starting at:  Sat Jan 20 17:22:28 2024
start loop  0  at  Sat Jan 20 17:22:28 2024
start loop  1  at  Sat Jan 20 17:22:28 2024
nloop  1  done at  Sat Jan 20 17:22:30 2024
nloop  0  done at  Sat Jan 20 17:22:32 2024
all DONE at:  Sat Jan 20 17:22:32 2024

• 在上述代码中，当实例化每个 Thread 对象时，把函数（target）和参数（args）传进去，然后得到返回的 Thread 实例。实例化 Thread 后，线程不会立即开始执行，而是把启动的指挥权交给程序员，这是一个非常有用的同步功能，尤其是当你并不希望线程开始立即执行时。
• 当所有线程都分配完成之后,通过调用每个线程的 start()方法让它们开始执行。
• join()方法将等待当前（或所有）线程结束后再往下执行。一旦线程启动,它们就会一直执行,直到给定的函数完成后退出。如果主线程还有其他事情要去做,而不是等待这些线程完成(例如其他处理或者等待新的客户端请求),就可以不调用 join()。join()方法只有在你需要等待线程完成的时候才是有用的。比如，如果将 join() 方法所在的 for 循环注释掉，那么执行脚本后将会得到下面这样的结果：

$ python myThread.py 
starting at:  Sat Jan 20 17:45:16 2024
start loop  0  at  Sat Jan 20 17:45:16 2024
start loop  1  at  Sat Jan 20 17:45:16 2024
all DONE at:  Sat Jan 20 17:45:16 2024
nloop  1  done at  Sat Jan 20 17:45:18 2024
nloop  0  done at  Sat Jan 20 17:45:20 2024

2、派生 Thread 的子类，并创建子类的实例

当创建线程时使用子类要相对更容易阅读，而且如上所述，当你需要一个更加符合面向对象的接口时,
会选择这种方法。下面的示例中将对 Thread 子类化,而不是直接对其实例化。这将使我们在定制线程对象时拥有更多的灵活性,也能够简化线程创建的调用过程。
示例代码：

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.func = func
        self.args = args
        self.name = name
    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():
    threads = []
    # 创建线程
    for i in range(len(loops)):
        t = MyThread(func=loop, args=(i,loops[i]), name=loop.__name__)
        threads.append(t)
    # 启动线程
    for i in range(len(loops)):
        threads[i].start()
    # 等待所有线程执行完毕
    for i in range(len(loops)):
        threads[i].join()
    print("all DONE at ", ctime())

if __name__ == "__main__":
    main()
    

执行脚本：

$ python myThread2.py 
start loop  0  at  Sat Jan 20 18:49:51 2024
start loop  1  at  Sat Jan 20 18:49:51 2024
loop  1 done at  Sat Jan 20 18:49:53 2024
loop  0 done at  Sat Jan 20 18:49:55 2024
all DONE at  Sat Jan 20 18:49:55 2024

• MyThread 子类的构造函数必须先调用其基类的构造函数。
• 当创建新线程时,Thread 类的代码将调用 MyThread 对象,此时会调用__run__()这个特殊方法。

补：Thread 对象的属性和方法