python中的线程了解与学习

大家好，欢迎来到IT知识分享网。

前言

       全局解释器锁（Global Interpreter Lock，简称GIL）是CPython解释器中一个重要的机制，其存在主要是为了确保线程安全和简化内存管理。它限制了单个进程在同一时间只能执行其中一个线程的代码。

一、计算密集型与IO操作密集型

       在Python中，多线程在处理计算密集型和I/O密集型任务时的效率提升情况有所不同，这主要受到全局解释器锁（Global Interpreter Lock，GIL）的影响。GIL确保了在任何时刻只有一个线程在执行Python字节码，这对于计算密集型任务来说，多线程并不能带来并行计算的优势，反而可能因为线程切换和GIL的获取与释放而增加额外的开销，导致多线程程序的运行速度甚至比单线程程序更慢。

1. 计算密集型任务

2. 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) 

这里输出的顺序可能因线程的调度而异。可以多执行几次其实能看到每次执行的情况有可能会不一样。

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) 

或者

主线程默认会等子线程执行完成。这里虽然看起来处于主线程中的123总是会在最后执行，但这里说的不是这个意思，需要注意以下四点说明：

1. 真正的本意是，主线程执行结束时，它会检查是否有任何子线程仍在运行。如果存在未完成的子线程，主线程将阻塞，直到所有子线程都执行完毕。（下面示例可以证明这一点）
2. 在 Python 的 threading 模块中，主线程等待子线程完成的行为是通过线程库内部的同步机制实现的。这种行为确保了程序的完整性，避免了主线程提前退出导致子线程资源未被正确释放或清理的问题。
3. 主线程等待子线程完成的机制主要由 Python 的线程库（如 threading 模块）实现，而不是由 GIL 控制的。即使有多个可用的处理器核心，GIL 也只允许一个线程在任何时刻执行 Python 代码。
4. 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) 

       拓展一下：守护线程具有以下特性：

1. 主程序退出时行为：当一个线程被标记为守护线程后，如果它是唯一剩下的线程，那么当主程序（即非守护线程）退出时，这个守护线程会立即被终止，而不会等待其完成。这意味着守护线程的存在不会阻止程序的正常退出。
2. 资源释放：守护线程通常用于执行后台任务，如心跳检测、日志记录或资源清理等。由于它们不持有关键资源或数据，因此在主程序退出时，可以安全地终止这些线程，而不会导致数据丢失或资源泄露。
3. 非重要任务：守护线程通常用于执行非关键任务，这些任务的完成与否不影响程序的主要功能。例如，一个用于检查网络连接状态的线程可以被设置为守护线程，因为即使它没有完成检查，主程序的其他功能仍然可以正常运行。
4. 生命周期管理：通过将线程设置为守护线程，可以简化程序的生命周期管理。开发人员不需要显式地管理所有线程的生命周期，而是可以依赖于Python的默认行为，即在主程序退出时自动终止所有守护线程。
5. 避免死锁：在多线程程序中，如果一个非守护线程等待另一个线程完成，而后者又在等待前者的某些操作，就可能产生死锁。将某些线程设置为守护线程可以避免这种情况，因为主程序退出时，所有守护线程都会被终止，从而打破可能的等待循环。

知道上面之后，我们再用一个例子使用一下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() 

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.start() t2.join(5) # 让主线程在这里最多等5秒，等到子线程t2执行完毕，才可以继续往下运行。 print(123) # 无参数，让主线程等着子线程，等到子线程比如t1执行完毕，才可以继续往下运行。 # 有参数，让主线程在这里最多等待n秒，过了n秒后，不管子线程比如t1是否执行完毕，主线程继续往下运行。 

        在Python的多线程编程中，t1.join(2) 这个方法调用具有特定的作用和含义。join() 方法用于等待一个线程完成其任务，或者等待指定的时间后返回。另外，调用 t1.join() 方法而不传递任何参数意味着主线程将无限期地等待线程 t1 完成其任务。

        展开拓展下，具体使用可展开以下四点：

1. 等待线程完成：如果线程 t1 在调用 join(2) 后的2秒内完成其任务，那么 join()方法会立即返回，主线程可以继续执行后续代码。
2. 超时机制：join() 方法接受一个可选的超时参数（以秒为单位）。在这个例子中，2 是超时时间。如果 t1线程在2秒内没有完成，join() 方法也会返回，即使 t1 线程尚未完成其任务。这意味着主线程不会无限期地等待 t1 线程，而是会在2秒后继续执行。
3. 控制执行顺序：join()方法常用于控制程序的执行顺序。例如，你可能希望确保某个线程完成其任务后再执行其他代码，以避免数据竞争或依赖关系问题。通过使用 join() 方法，你可以确保主线程在继续执行之前等待特定线程的完成。
4. 避免死锁：在复杂的多线程程序中，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() 

注意：这里不要跟上面的第三点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() 

2.5 为什么有时候多线程运行的时候结果是不一样的？

1. 线程调度：操作系统负责线程的调度，它决定哪个线程在何时获得CPU时间片。线程的执行顺序和时间点取决于操作系统的调度策略，这可能因系统负载、优先级和其他系统活动而变化。
2. 并发执行：由于线程可以并发执行，t1 和 t2 可能在任意时间点开始执行，甚至可能同时执行。这意味着 func(111) 和
   func(222) 的输出可能交错出现，或者一个线程的输出完全在另一个线程之前或之后。
   
3. 主线程的执行：主线程在启动子线程后继续执行，打印 123。然而，由于线程调度的不确定性，123 的输出可能在 t1 和 t2
   的输出之前、之后，或者它们之间。
   
4. 随机性：每次运行程序时，操作系统的状态（如当前的CPU使用情况、其他正在运行的进程等）可能不同，这会影响线程的调度和执行。因此，即使代码相同，每次运行的结果也可能因为这些随机因素而不同。

2.6 再补充一个创建线程的方法

import threading class MyThread(threading.Thread): def run(self): print("xixi",self._args,self._kwargs) t1 = MyThread(args=(11,)) t1.start() t1.join() t2 = MyThread(args=(22,)) t2.start() t2.join() print('end') 

1. 在Python的threading模块中，当你创建一个Thread对象并调用其start()方法时，Python会自动在新线程中调用你定义的run()方法。这是threading.Thread类设计的一部分，其目的是为了简化多线程编程。
2. 当创建一个Thread对象时，例如t1 = MyThread(args=(11,))，实际上是在创建一个继承自threading.Thread的子类的实例。threading.Thread类的start()方法内部实现了调用run()方法的逻辑。具体来说：
          start()方法：当你调用t1.start() 时，threading.Thread的start()方法被调用。这个方法首先会创建一个线程，并将self.run（即run()方法）作为目标函数，然后启动这个线程。
          run()方法：start()方法内部会调用self._target(*self._args, self._kwargs)，这里的self._target默认就是self.run，即重写的run()方法。因此，当线程开始执行时，它会调用run()方法，并将在创建Thread对象时传递的参数传给run()方法。
   
   

为什么不能直接调用run()？

1. start()方法的内部机制：当创建一个Thread对象并调用其start()方法时，以下步骤会发生：
       线程创建：start()方法首先会创建一个新的线程。这个新线程将独立于调用start()的主线程运行。
       目标函数设置：start()方法会将Thread对象的run()方法设置为新线程的目标函数。这意味着当新线程开始运行时，它将执行run()方法。
       线程启动：start()方法会启动新线程，使它进入就绪状态，等待CPU调度。一旦被调度，新线程将开始执行run()方法。
   
   
   
2. run()方法是Thread类中的一个特殊方法，它定义了线程要执行的任务。当你继承Thread类并重写run()方法时，你实际上是在定义新线程的行为。当start()方法被调用时，run()方法将在新线程的上下文中执行，而不是在调用start()的主线程中执行。
3. 直接调用run()方法不会启动一个新的线程。相反，它会在当前线程（通常是主线程）中像普通函数一样执行。这意味着run()方法的执行将阻塞主线程，直到run()方法完成。此外，run()方法的调用将不会利用多线程的优势，因为它仍然在主线程中执行。

三、总结

• 对于计算密集型任务，Python的多线程通常不会提高效率，甚至可能降低效率。
• 对于I/O密集型任务，多线程可以显著提高程序的执行效率，因为线程可以在等待I/O操作时释放GIL，允许其他线程执行。
• 由于线程的并发性和操作系统的调度机制，每次运行时，func 函数的输出与主线程输出的相对顺序可能会有所不同。这种不确定性是多线程编程的一个固有特性，需要通过适当的同步机制（如锁、信号量、条件变量等）来控制线程之间的交互，以确保程序的正确性和可预测性。
• 主线程执行结束时，它会检查是否有任何子线程仍在运行。如果存在未完成的子线程，主线程将阻塞，直到所有子线程都执行完毕。
• 使用setDaemon(True)方法，用于将子线程设置为守护线程（daemonthread），从而影响程序的终止方式。主线程不会阻塞，不会等子线程运行，主线程运行完之后会直接终止程序。
• 使用join() 方法用于等待一个线程完成其任务，或者等待指定的时间后返回。如果线程 t1 在调用 join(2) 后的2秒内完成其任务，那么 join()方法会立即返回，主线程可以继续执行后续代码；如果 t1线程在2秒内没有完成，join() 方法也会返回，即使 t1 线程尚未完成其任务。这意味着主线程不会无限期地等待 t1 线程。