模块级函数说明
threading.active_count()返回当前活动的Thread对象的数量,与enumerate()函数返回的列表元素个数相同
threading.current_thread()返回当前Thread对象,对应调用者的控制线程(thread of control)。如果调用者的控制线程不是通过threading模块创建,返回一个功能受限的哑线程对象(dummy thread object)
threading.get_ident()返回一个非零整数,代表当前线程的"线程标识符"。这个值意在作为魔术cookie使用,例如作为索引从特定于线程的字典对象获取数据。当一个线程退出,新的线程创建,线程标识符可能被回收使用
threading.enumerate()返回当前活动Thread对象的列表。该列表包含守护线程、current_thread()函数创建的哑线程,以及主线程,不包含已终止的线程和未启动的线程。
threading.main_thread()返回主线程对象。通常来说,主线程就是启动python解释器的线程。
threading.settrace(func)为启动自threading模块的所有线程设置一个trace函数。在每个线程的run()方法调用前,传递func参数给sys.settrace()
threading.setprofile(func)为启动自threading模块的所有线程设置一个profile函数。在每个线程的run()方法调用前,传递func参数给sys.setprofile()
threading.stack_size([size])返回创建新线程使用的线程堆栈大小。可选参数size指定后续创建的线程的堆栈大小,必须是0(表示使用平台或配置的默认值)或大于等于32768(32KiB)的正整数。如果未指定,默认size为0.如果不支持改动线程堆栈大小,抛出RuntimeError异常。如果size不合法,抛出ValueError异常,堆栈大小保持不变。32KiB是目前能保证解释器堆栈空间充足的最小值。某些平台可能对堆栈大小做了特殊的限制,比如要求最小堆栈大小在32KiB以上,或要求以系统内存页大小的倍数分配。Windows系统及使用POSIX线程的系统可用

Thread类

Thread类代表在单独的控制线程中运行的活动,有两种方式指定:传递可调用对象到构造器的target参数,或重写子类的run()方法。除了__int__()方法和run()方法,Thread子类不应该重写除此之外的其他方法。
创建的线程对象,必须使用start()方法启动,start()在一个单独的控制线程调用run()方法。这时该线程被认为是"活动的"。当run()方法结束(正常执行完成或抛出了未处理的异常)时,线程对象不再是"活动的"。is_alive()方法可用于检查线程是否处于活动状态。
调用线程对象的join()方法将导致线程阻塞,直到调用join()方法的线程执行结束。
线程拥有名字,可以传递给构造器。通过name属性读取或修改。
主线程:对应python程序的初始控制线程。主线程不是守护线程。
守护线程:当没有非守护线程处于活动状态时,整个python程序将退出。通过daemon属性或构造器参数,可以标记一个线程为守护线程。daemon属性的初始值继承自创建该线程的线程
哑线程:对应"外部线程"alien thread,即在threading模块之外(比如C代码)启动的控制线程。哑线程具有有限的功能,总是认为是活动的和守护的,不能调用join()方法。它们永远不会被删除,因为不能检测外部线程的结束情况。
Note:守护线程将在程序关闭时直接停止。相关资源(比如打开的文件、数据库事务等)可能不会被妥善地释放。如果想要线程优雅地停止,将线程设置为非守护线程,并使用合适的信号机制比如Event

class threading.Thread(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)

  • group:None。作为将来实现ThreadGroup类后的保留参数。
  • target:可调用对象,将被run()方法调用
  • name:线程名称。默认构建Thread-N形式的唯一名称。
  • args:target调用需要接收的位置参数,元组形式
  • kwargs:target调用需要接收的关键字参数,字典形式
  • daemon:传递一个布尔值,标记该线程是否为守护线程。None表示继承创建该线程的当前线程的daemon属性。

如果子类继承Thread并重写构造器,必须确保在执行线程的其他操作前在构造器中调用Thread.__init__()

start()

开启线程。每个线程最多只能调用一次,否则抛出RuntimeError异常。它将在一个单独的控制线程调用线程对象的run()方法。

run()

定义线程功能的方法,通常在子类中重写。标准的run()方法调用传入构造器的可调用对象target(存在的话),并使用args和kwargs分别作为target的位置参数和关键字参数。

# 创建Thread的实例,传给它一个函数

from threading import Thread
from time import sleep, ctime

sleep_time = [4, 2]


def task(task_tag, sleep_tag):
    print("task", task_tag, "started at:", ctime())
    sleep(sleep_tag)
    print("task", task_tag, "done at:", ctime())


def main():
    print("Main thread started at:", ctime())
    threads = []
    nloops = range(len(sleep_time))  # [0, 1]

    for i in nloops:
        t = Thread(target=task, args=(i, sleep_time[i]))
        threads.append(t)

    for i in nloops:
        threads[i].start()  # 启动线程

    for i in nloops:
        threads[i].join()  # 主线程阻塞,直至调用join()方法的线程终止

    print("Main thread done at:", ctime())


if __name__ == '__main__':
    main()
# 派生Thread的子类,并创建子类的实例

from threading import Thread
from time import sleep, ctime

sleep_time = [4, 2]


class MyThread(Thread):
    # 重写run()方法
    def run(self):
        print(self.name, "started at:", ctime())
        self._target(self._args)
        print(self.name, "done at:", ctime())


def task(sleep_tag):
    sleep(sleep_tag)


def main():
    print("Main thread started at:", ctime())
    threads = []
    nloops = range(len(sleep_time))

    for i in nloops:
        t = MyThread(target=task, args=sleep_time[i], name=task.__name__ + str(i))
        threads.append(t)

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

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

    print("Main thread done at:", ctime())


if __name__ == '__main__':
    main()

join(timeout=None)

阻塞主线程直到调用join方法的线程终止(可能是正常执行完成,也可能是抛出了未处理的异常)或达到timeout设定的时间。可多次调用。

  • timeout:阻塞时间(秒)。如果为None,表示一直阻塞直至调用join方法的线程终止;如果不为None,表示阻塞的时间,达到该时间后,不管调用join()方法的线程是否执行完成,继续执行主线程或其他启动的线程。
    如果线程调用join()方法可能导致死锁,或在调用start()之前调用join(),抛出RuntimeError异常。

name

获取或设置线程名称。多个线程可能名称相同,初始值由构造器设置。

ident

线程标识符,如果为None说明该线程未启动。当一个线程退出,新的线程创建,线程标识符可能被回收使用。即使线程退出,该标识符仍可用。

is_alive()

判断线程是否处于活动状态。

daemon

布尔标志,表示这个线程是否是守护线程。必须在调用start()之前设置,否则抛出RuntimeError异常。初始值继承自创建该线程的线程。主线程不是守护线程,因此在主线程中创建的线程daemon属性默认值为False
CPython实现细节:在CPython中,由于GIL的原因,一次只有一个线程能够执行python代码(即使某些面向性能的库能克服这个限制???)。想要python程序更好地利用多核机器的计算机资源(计算密集型),建议使用multiprocessing或concurrent.futures.ProcessPoolExecutor。如果是同时运行多个I/O密集型任务,threading仍然不失为一个合适的模块

Lock

原语锁,是同步原语的一种,当它处于"locked"状态时不属于特定线程。在python中,这是目前可用的最低级的同步原语,实现自_thread扩展模块。
原语锁有两种状态:locked(锁定)或unlocked(未锁定)。创建时为未锁定状态。
原语锁有两种方法:acquire()和release()。当锁处于未锁定状态时,acquire()改变其为锁定状态。当锁处于锁定状态时,调用acquire()方法将导致线程阻塞,直到其他线程调用release()释放锁。
class threading.Lock

acquire(blocking=True, timeout=-1)

获取锁。成功返回True,获取返回False。

  • blocking:默认为True,在获取到锁之前阻塞线程;反之即使没有获取到锁也不会阻塞线程。
  • timeout:指定线程阻塞的最长时间,单位为秒;-1表示无限制等待。当blocking为False时,禁止指定timeout参数

release()

释放锁。任何线程都可以调用,不只是获取了锁的线程。
锁更改为未上锁状态后,对于调用了acquire()方法而导致阻塞的线程,将由系统决定哪个线程获取到锁。
release()方法只能在上锁状态调用,否则将抛出RuntimeError异常。

RLock

重入锁,同步原语的一种,可由同一线程多次获取已持有的锁。除了原语锁的上锁/解锁状态,重入锁还使用了owning thread和recursion level的概念。在上锁状态,可能有多个线程拥有锁;在解锁状态,没有线程拥有锁。
acquire()/release()必须成对出现,可以嵌套,只有最后一个release(即最外层的release)调用才会最终释放锁。

class threading.RLock

acquire(blocking=True, timeout=-1)

使用默认参数调用时,如果当前线程已经拥有锁,增加1次递归深度并立即返回;如果是其他线程拥有锁,阻塞当前线程直到锁被释放。一旦锁释放(递归深度为0,此时锁不属于任何线程),各个线程争夺锁,并设置递归深度为1。

release()

释放锁且递归深度减1。如果调用后递归深度为0,重置锁为未锁定状态(不属于任何线程),由其他线程争夺锁。如果调用后递归深度非0,锁仍为上锁状态,属于当前线程。
只能由已经获取了锁的线程调用,否则抛出RuntimeError异常。

参考:https://segmentfault.com/a/1190000018363577