python中的线程了解与学习

---

前言

       全局解释器锁（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总是会在最后执行，但这里说的不是这个意思，需要注意以下四点说明：

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)

123 结果是123
这里用到 setDaemon(True) 方法，用于将子线程设置为守护线程（daemonthread），从而影响程序的终止方式。在上面例子中，直接打印123，主线程不会阻塞，不会等子线程的3秒，主线程运行完之后会直接终止程序。

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

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()

        在这个例子中，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 完成其任务。

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

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()

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 为什么有时候多线程运行的时候结果是不一样的？

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

三、总结

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