Python的进程和线程——一些基础概念

1. 线程和进程

1.1 线程和进程

1. 进程可以包含多个并行运行的线程；

2. 通常，操作系统创建和管理线程比进程更省CPU资源；

3. 线程用于一些小任务，进程用于繁重的任务；

4. 同一个进程下的线程共享地址空间和其他资源，进程之间相互独立；

1.2 线程 v.s. 进程：

1.2.1 多线程

• 多线程是在同一进程内部创建多个线程来执行任务的技术。每个线程共享相同的内存空间，因此可以轻松共享数据。
• 多线程适合于 I/O 密集型任务，如网络请求、文件操作等，因为线程之间的切换开销较小。
• Python 中的多线程通常由 threading 模块实现。

1.2.2 多进程

• 多进程是在操作系统级别创建多个独立的进程来执行任务的技术。每个进程都有自己独立的内存空间，数据不共享，需要通过 IPC（进程间通信）来传递数据。
• 多进程适合于 CPU 密集型任务，如数值计算、图像处理等，因为多进程能够充分利用多核处理器的能力。
• Python 中的多进程通常由 multiprocessing 模块实现。

1.2.3 区别

1. 内存和资源开销：多线程共享同一进程的内存空间，因此创建线程的开销较小；而多进程每个进程都有独立的内存空间，创建进程的开销较大。

2. 数据共享：多线程可以轻松共享数据，因为它们共享相同的内存空间；而多进程需要通过 IPC 来传递数据，因为它们的内存空间是独立的。

3. CPU 利用率：多线程适合于 I/O 密集型任务，因为线程切换开销较小；多进程适合于 CPU 密集型任务，因为可以充分利用多核处理器的能力。

总的来说，多线程适合于需要频繁进行 I/O 操作的任务，而多进程适合于需要大量 CPU 计算的任务。

2. I/O密集型任务和CPU密集型任务

在计算机编程中，任务通常可以根据它们是如何使用计算机资源的来分类。主要有两种类型：I/O 密集型任务和 CPU 密集型任务。

2.1 I/O 密集型任务

I/O 是 Input/Output（输入/输出）的缩写。当说到 I/O 密集型任务时，我们通常是指那些需要大量数据输入和输出的任务。这些任务往往涉及到磁盘、网络或其他类型的数据传输。

特点:

• 等待时间: I/O 操作往往需要等待，比如等待磁盘旋转到正确的位置来读取数据，或者等待网络上的数据包到达。
• CPU 使用率: 在等待数据传输的过程中，CPU 往往是空闲的，因为它不能在没有数据的情况下继续工作。
• 例子: 比如，从一个很大的文件中读取数据，或者从互联网上下载一个文件。这些操作大部分时间都在等待数据到来，而不是在进行大量的计算。

2.2 CPU 密集型任务

CPU 密集型任务是指那些需要大量计算的任务，它们会充分利用 CPU 的计算能力。

特点:

• 计算量大: 这类任务涉及复杂的计算，如图形处理、数据分析、加密解密等。
• CPU 使用率: 在执行这类任务时，CPU 通常会保持高使用率，因为它一直在进行计算。
• 例子: 比如，对一张高分辨率图片进行复杂的图像处理，或者计算一个大型数据集的统计分析。这些任务需要 CPU 进行大量的数学运算。

想象一下，你在厨房里准备晚餐。I/O 密集型任务就像是你在等待水烧开或者烤箱预热。在这期间，你基本上无事可做，只能等待。CPU 密集型任务则像你在切菜、拌沙拉或进行烹饪，你需要不断地工作，直到完成。

在编程中，我们选择多线程、多进程或其他并发模型，取决于任务的类型。如果任务主要是 I/O 密集型的，那么多线程可能会有所帮助，因为线程可以在等待 I/O 操作完成时被操作系统挂起，让其他线程运行。而如果任务是 CPU 密集型的，那么多进程可能更合适，因为每个进程可以在 CPU 上真正地并行运行，从而实现更快的处理速度。

3. 主线程和子线程

在多线程编程中，主线程（Main Thread） 和子线程（Child Thread） 是用来描述线程之间关系的术语。

3.1 主线程（Main Thread）

• 定义: 主线程通常指的是程序启动时创建的第一个线程，它是执行程序主流程的线程。
• 作用: 主线程负责程序的主要逻辑和控制流程，包括启动其他线程（子线程）和管理它们。
• 生命周期: 通常，主线程会持续运行直到程序的所有任务完成，或者直到它被显式终止。

3.2 子线程（Child Thread）

• 定义: 子线程是指由主线程创建的额外线程，用于并行执行任务。
• 作用: 子线程可以用于执行特定的任务，如后台处理、I/O 操作、计算密集型任务等，以提高程序的效率和响应性。
• 生命周期: 子线程的生命周期通常依赖于它们所执行的任务。一旦任务完成，子线程就会结束。

3.3 主线程和子线程的关系

• 创建: 主线程可以创建一个或多个子线程。
• 同步: 主线程可能会等待（通过 join() 方法）子线程完成，以确保在继续执行之前子线程的任务已经结束。
• 协作: 主线程和子线程可以共享数据和资源，但需要同步机制（如锁）来避免竞态条件和数据不一致。
• 结束: 主线程的结束通常意味着程序的结束，除非它等待子线程完成。子线程的结束仅表示它们所负责的任务已经完成。

3.4 示例

假设你有一个 Python 程序，它使用 threading 模块创建了多个线程：

import threading
import time

def child_thread_task(name):
    print(f"Child thread {name} is running.")
    time.sleep(1)
    print(f"Child thread {name} has finished.")

def main_thread_task():
    print("Main thread is setting up child threads.")
    threads = []
    for i in range(3):
        t = threading.Thread(target=child_thread_task, args=(i,))
        threads.append(t)
        t.start()

    # 主线程等待所有子线程完成
    for t in threads:
        t.join()

    print("All child threads have completed. Main thread is finishing.")

if __name__ == "__main__":
    main_thread_task()  # 主线程的任务

[Run]

Main thread is setting up child threads.
Child thread 0 is running.
Child thread 1 is running.
Child thread 2 is running.
Child thread 2 has finished.Child thread 1 has finished.
Child thread 0 has finished.

All child threads have completed. Main thread is finishing.

在这个示例中：

• main_thread_task() 函数中的代码运行在主线程上，它负责创建和启动子线程。
• child_thread_task() 函数中的代码运行在子线程上，每个子线程执行一个独立的任务。
• 主线程使用 join() 方法等待所有子线程完成后才结束。

4. 锁

4.1 什么是锁

在计算机编程中，锁是一种用来控制对共享资源（如内存、文件等）访问的机制。当多个线程（程序执行的独立流）需要同时运行时，锁可以帮助避免它们在不适当的时刻相互干扰。

4.2 为什么要使用锁

想象一下，如果有多个小孩同时在一个图书馆里，他们都想写同一本书。如果没有规则，他们可能会相互覆盖对方的内容，导致书变得乱七八糟。锁就像是图书馆的规则，它确保一次只有一个人能够写这本书。

在计算机中，当多个线程需要修改同一个变量时，如果不使用锁，就可能出现类似的情况，这被称为 “竞态条件” 。竞态条件会导致程序的行为变得不可预测，因为最终结果取决于线程执行的顺序，而这个顺序是无法控制的。

4.3 锁是如何工作的

锁的工作原理很简单：

1. 获取锁: 当一个线程想要修改一个共享资源时，它首先需要“获取”（或“锁定”）一个锁。这通常通过调用 acquire() 方法来实现。

2. 执行操作: 一旦线程获取了锁，它就可以安全地执行对共享资源的修改，因为其他线程必须等待锁被释放。

3. 释放锁: 修改完成后，线程会“释放”（或“解锁”）锁，这通常通过调用 release() 方法来实现。这样，其他等待锁的线程就可以继续执行。

4.4 锁的类型

1. 互斥锁（Mutex Lock）: 最常见的锁类型，一次只允许一个线程获取锁。

2. 递归锁（Recursive Lock）: 允许同一个线程多次获取同一个锁，避免了递归函数中的死锁问题。

3. 读写锁（RWLock）: 允许多个读取操作同时进行，但写操作是排他的。

4. 信号量（Semaphore）: 类似于锁，但可以设定一个计数值，允许多个线程同时访问资源。

5. 条件锁（Condition）: 允许线程在某个条件成立之前挂起，直到其他线程发出信号。

4.5 使用锁的例子

假设我们有一个变量 counter，我们希望两个线程能够交替地对其进行加一操作。

import threading

counter = 0
lock = threading.Lock()

def increment():
    global counter
    for _ in range(100000):
        lock.acquire()  # 获取锁
        counter += 1
        lock.release()  # 释放锁

thread1 = threading.Thread(target=increment)
thread2 = threading.Thread(target=increment)

thread1.start()
thread2.start()

thread1.join()
thread2.join()

print(counter)  # 应该打印 200000

在这个例子中，lock 确保了 counter 的增加操作是安全的，即使两个线程在同时运行。如果没有 lock，两个线程可能会同时读取和修改 counter，导致最终结果不正确。

4.6 注意事项：

• 死锁: 如果不正确地使用锁，可能会导致死锁，即两个或多个线程相互等待对方释放锁，但没有一个线程愿意放弃，导致程序停止响应。

• 性能: 过度使用锁可能会降低程序的性能，因为线程需要等待获取锁。

• 避免锁: 在可能的情况下，尽量避免使用共享资源，或者使用线程局部数据，这样可以减少对锁的需求。

正确地使用锁对于避免竞态条件和确保程序的正确性至关重要。