文章目录
前言
全局解释器锁(Global Interpreter Lock,简称GIL)是CPython解释器中一个重要的机制,其存在主要是为了确保线程安全和简化内存管理。它限制了单个进程在同一时间只能执行其中一个线程的代码。
一、计算密集型与IO操作密集型
在Python中,多线程在处理计算密集型和I/O密集型任务时的效率提升情况有所不同,这主要受到全局解释器锁(Global Interpreter Lock,GIL)的影响。GIL确保了在任何时刻只有一个线程在执行Python字节码,这对于计算密集型任务来说,多线程并不能带来并行计算的优势,反而可能因为线程切换和GIL的获取与释放而增加额外的开销,导致多线程程序的运行速度甚至比单线程程序更慢。
1. 计算密集型任务
GIL限制:由于GIL的存在,即使在多核处理器上,Python的多线程也无法实现真正的并行计算。这意味着在处理大量计算任务时,多线程并不能显著提高程序的执行速度。
线程切换开销:线程之间的切换以及GIL的获取和释放会消耗额外的CPU时间,对于计算密集型任务,这些开销可能会抵消多线程带来的任何潜在优势。
2. I/O密集型任务
GIL释放:在I/O密集型任务中,当一个线程在等待I/O操作完成时,GIL会被释放,允许其他线程执行。这意味着在等待I/O操作的同时,其他线程可以继续执行计算任务,从而提高整体的程序效率。
并行处理:对于如网络请求、磁盘读写等I/O密集型操作,多线程可以显著提高效率。例如,在爬虫应用中,多个线程可以同时发送网络请求,当一个线程在等待响应时,其他线程可以继续执行,这样可以在较短的时间内完成更多的请求
二、线程的创建和使用
2.1 线程的简单创建和使用
# 使用 Python 的 threading 模块来创建和启动一个线程
import threading
def func(arg):
print(arg)
# 创建一个新的线程 t,指定了其目标函数为 func。传递给函数的参数是元组 ("111",)。
# 这里使用了一个元组,即使只传递一个参数,元组后面也需要加上一个逗号,以表明这是一个元组
t = threading.Thread(target=func, args=("111",))
# 启动线程 t。这会在单独的线程中执行 func("111")
t.start()
print(123)
这里输出的顺序可能因线程的调度而异。可以多执行几次其实能看到每次执行的情况有可能会不一样。
111
123
或者
111123
2.2 创建两个线程
import threading
def func(arg):
print(arg)
t1 = threading.Thread(target=func, args=(111,))
t1.start()
t2 = threading.Thread(target=func, args=(222,))
t2.start()
print(123)
111
222
123或者
111
222123
主线程默认会等子线程执行完成。这里虽然看起来处于主线程中的123总是会在最后执行,但这里说的不是这个意思,需要注意以下四点说明:
- 真正的本意是,主线程执行结束时,它会检查是否有任何子线程仍在运行。如果存在未完成的子线程,主线程将阻塞,直到所有子线程都执行完毕。(下面示例可以证明这一点)
- 在 Python 的 threading 模块中,主线程等待子线程完成的行为是通过线程库内部的同步机制实现的。这种行为确保了程序的完整性,避免了主线程提前退出导致子线程资源未被正确释放或清理的问题。
- 主线程等待子线程完成的机制主要由 Python 的线程库(如 threading 模块)实现,而不是由 GIL 控制的。即使有多个可用的处理器核心,GIL 也只允许一个线程在任何时刻执行 Python 代码。
- GIL影响了多线程程序的执行效率,但它并不直接影响主线程等待子线程的机制。线程等待子线程的行为是由线程库的同步机制控制的,而 GIL 主要关注的是线程间的执行顺序和对共享资源的访问控制。在多线程程序中,GIL 可能会导致线程切换和上下文切换的开销,但主线程等待子线程的逻辑独立于 GIL 的存在
# 证明上面的说明1: 主线程执行结束时,它会检查是否有任何子线程仍在运行。如果存在未完成的子线程,主线程将阻塞,直到所有子线程都执行完毕。
import threading
import time
def func(arg):
time.sleep(3)
print(arg)
t1 = threading.Thread(target=func, args=(111,))
t1.start()
t2 = threading.Thread(target=func, args=(222,))
t2.start()
print(123)
这里它会先显示123,然后主线程阻塞,等3s后,显示111和222。
2.3 创建两个线程,并且不让主线程等子线程了。
即直白一点:不管子线程运行的进度如何,主线程终止其他所有子线程也终止
简单先来一个例子:
import threading
import time
def func(arg):
time.sleep(3)
print(arg)
t1 = threading.Thread(target=func, args=(111,))
t1.setDaemon(True)
t1.start()
t2 = threading.Thread(target=func, args=(222,))
t2.setDaemon(True)
t2.start()
print(123)
123 结果是123
这里用到 setDaemon(True) 方法,用于将子线程设置为守护线程(daemonthread),从而影响程序的终止方式。在上面例子中,直接打印123,主线程不会阻塞,不会等子线程的3秒,主线程运行完之后会直接终止程序。
拓展一下:守护线程具有以下特性:
- 主程序退出时行为:当一个线程被标记为守护线程后,如果它是唯一剩下的线程,那么当主程序(即非守护线程)退出时,这个守护线程会立即被终止,而不会等待其完成。这意味着守护线程的存在不会阻止程序的正常退出。
- 资源释放:守护线程通常用于执行后台任务,如心跳检测、日志记录或资源清理等。由于它们不持有关键资源或数据,因此在主程序退出时,可以安全地终止这些线程,而不会导致数据丢失或资源泄露。
- 非重要任务:守护线程通常用于执行非关键任务,这些任务的完成与否不影响程序的主要功能。例如,一个用于检查网络连接状态的线程可以被设置为守护线程,因为即使它没有完成检查,主程序的其他功能仍然可以正常运行。
- 生命周期管理:通过将线程设置为守护线程,可以简化程序的生命周期管理。开发人员不需要显式地管理所有线程的生命周期,而是可以依赖于Python的默认行为,即在主程序退出时自动终止所有守护线程。
- 避免死锁:在多线程程序中,如果一个非守护线程等待另一个线程完成,而后者又在等待前者的某些操作,就可能产生死锁。将某些线程设置为守护线程可以避免这种情况,因为主程序退出时,所有守护线程都会被终止,从而打破可能的等待循环。
知道上面之后,我们再用一个例子使用一下setDaemon(True) 方法:
import threading
import time
def daemon_thread():
while True:
print("Daemon thread running...")
time.sleep(1)
def main():
t1 = threading.Thread(target=daemon_thread)
t1.setDaemon(True)
t1.start()
time.sleep(5) # 主线程等待5秒
print("Main thread exiting.")
if __name__ == "__main__":
main()
在这个例子中,daemon_thread 函数定义了一个无限循环的线程。一般情况下,如果这个线程不是守护线程,那么主程序将无法正常退出,因为主线程它会一直等待daemon_thread 完成。但是,通过调用 t1.setDaemon(True),我们确保了即使 daemon_thread没有完成,主程序也可以正常退出,而 daemon_thread 会被操作系统销毁回收。
setDaemon(True) 在Python中用于将线程标记为守护线程,这影响了程序的终止方式。守护线程的主要作用是执行非关键的后台任务,这些任务可以安全地在主程序退出时被终止,而不会影响程序的正常运行。
2.4 创建两个线程,并且设置主线程等待子线程的最大等待时间。
上面2.3学习起来觉得它不友好,能不能让主线程主动一些,设置一下等待子线程的最大等待时间,然后再终止程序?
还是一样,来个例子说明下:
import threading
import time
def func(arg):
time.sleep(3)
print(arg)
t1 = threading.Thread(target=func, args=(111,))
t1.start()
t1.join(5) # 让主线程在这里最多等5秒,等到子线程t1执行完毕,才可以继续往下运行。
t2 = threading.Thread(target=func, args=(222,))
t2.setDaemon(True)
t2.start()
t2.join(5) # 让主线程在这里最多等5秒,等到子线程t2执行完毕,才可以继续往下运行。
print(123)
# 无参数,让主线程等着子线程,等到子线程比如t1执行完毕,才可以继续往下运行。
# 有参数,让主线程在这里最多等待n秒,过了n秒后,不管子线程比如t1是否执行完毕,主线程继续往下运行。
结果是这样打印的:
先等3秒,打印111,再等3秒,打印222,然后瞬间打印123。
在Python的多线程编程中,t1.join(2) 这个方法调用具有特定的作用和含义。join() 方法用于等待一个线程完成其任务,或者等待指定的时间后返回。另外,调用 t1.join() 方法而不传递任何参数意味着主线程将无限期地等待线程 t1 完成其任务。
展开拓展下,具体使用可展开以下四点:
- 等待线程完成:如果线程 t1 在调用 join(2) 后的2秒内完成其任务,那么 join()方法会立即返回,主线程可以继续执行后续代码。
- 超时机制:join() 方法接受一个可选的超时参数(以秒为单位)。在这个例子中,2 是超时时间。如果 t1线程在2秒内没有完成,join() 方法也会返回,即使 t1 线程尚未完成其任务。这意味着主线程不会无限期地等待 t1 线程,而是会在2秒后继续执行。
- 控制执行顺序:join()方法常用于控制程序的执行顺序。例如,你可能希望确保某个线程完成其任务后再执行其他代码,以避免数据竞争或依赖关系问题。通过使用 join() 方法,你可以确保主线程在继续执行之前等待特定线程的完成。
- 避免死锁:在复杂的多线程程序中,join()方法的超时机制可以帮助避免潜在的死锁情况。如果一个线程在等待另一个线程完成时,后者又在等待前者的某些操作,就可能产生死锁。通过设置join() 的超时,可以避免无限期等待,从而减少死锁的风险。
再来个例子:
import threading
import time
def thread_function():
print("Thread started.")
time.sleep(3) # 模拟耗时操作
print("Thread finished.")
def main():
t1 = threading.Thread(target=thread_function)
t1.start()
t1.join(2) # 等待 t1 完成,最多等待2秒
print("Main thread continues...")
if __name__ == "__main__":
main()
Thread started.
Main thread continues…
Thread finished.
说明:在这个例子中,thread_function 函数定义了一个线程,该线程会执行一个耗时3秒的操作。主线程调用 t1.join(2) 来等待 t1 线程的完成,但最多只等待2秒。如果 t1 线程在2秒内完成,那么 join() 方法会立即返回,主线程继续执行。如果 t1 线程在2秒后仍未完成,join() 方法也会返回,主线程继续执行,而 t1 线程继续运行直到完成。
注意:这里不要跟上面的第三点setDaemon(True) 方法搞混了,正常来说,没有使用setDaemon(True) 方法等守护线程手段时,主线程还是会hang住,阻塞住,等所有的子线程运行完之后,才会终止程序。
把上面再改一下, 不给加等待时间的参数了:
import threading
import time
def thread_function():
print("Thread started.")
time.sleep(3) # 模拟耗时操作
print("Thread finished.")
def main():
t1 = threading.Thread(target=thread_function)
t1.start()
t1.join() # 等待 t1 完成,没有超时限制
print("Main thread continues...")
if __name__ == "__main__":
main()
Thread started.
Thread finished.
Main thread continues…
说明:thread_function 函数定义了一个线程,该线程会执行一个耗时3秒的操作。主线程调用 t1.join() 来等待 t1 线程的完成,没有设置超时。这意味着主线程将无限期地等待,直到 t1 线程完成其任务。只有当 t1 线程的 time.sleep(3) 操作完成后,join() 方法才会返回,主线程继续执行后续代码。对,这里就跟上面2.2是一样的。
2.5 为什么有时候多线程运行的时候结果是不一样的?
- 线程调度:操作系统负责线程的调度,它决定哪个线程在何时获得CPU时间片。线程的执行顺序和时间点取决于操作系统的调度策略,这可能因系统负载、优先级和其他系统活动而变化。
- 并发执行:由于线程可以并发执行,t1 和 t2 可能在任意时间点开始执行,甚至可能同时执行。这意味着 func(111) 和
func(222) 的输出可能交错出现,或者一个线程的输出完全在另一个线程之前或之后。 - 主线程的执行:主线程在启动子线程后继续执行,打印 123。然而,由于线程调度的不确定性,123 的输出可能在 t1 和 t2
的输出之前、之后,或者它们之间。 - 随机性:每次运行程序时,操作系统的状态(如当前的CPU使用情况、其他正在运行的进程等)可能不同,这会影响线程的调度和执行。因此,即使代码相同,每次运行的结果也可能因为这些随机因素而不同。
三、总结
- 对于计算密集型任务,Python的多线程通常不会提高效率,甚至可能降低效率。
- 对于I/O密集型任务,多线程可以显著提高程序的执行效率,因为线程可以在等待I/O操作时释放GIL,允许其他线程执行。
- 由于线程的并发性和操作系统的调度机制,每次运行时,func 函数的输出与主线程输出的相对顺序可能会有所不同。这种不确定性是多线程编程的一个固有特性,需要通过适当的同步机制(如锁、信号量、条件变量等)来控制线程之间的交互,以确保程序的正确性和可预测性。
- 主线程执行结束时,它会检查是否有任何子线程仍在运行。如果存在未完成的子线程,主线程将阻塞,直到所有子线程都执行完毕。
- 使用setDaemon(True)方法,用于将子线程设置为守护线程(daemonthread),从而影响程序的终止方式。主线程不会阻塞,不会等子线程运行,主线程运行完之后会直接终止程序。
- 使用join() 方法用于等待一个线程完成其任务,或者等待指定的时间后返回。如果线程 t1 在调用 join(2) 后的2秒内完成其任务,那么 join()方法会立即返回,主线程可以继续执行后续代码;如果 t1线程在2秒内没有完成,join() 方法也会返回,即使 t1 线程尚未完成其任务。这意味着主线程不会无限期地等待 t1 线程。