什么是多线程和多进程？

CM莫问

于 2024-12-06 20:23:18 发布

阅读量1.1k

点赞数 37

分类专栏：人工智能算法常见概念文章标签：人工智能机器学习算法 python

本文链接：https://blog.youkuaiyun.com/ChaneMo/article/details/144213652

版权

人工智能算法常见概念专栏收录该内容

53 篇文章

订阅专栏

一、概念

在Python中，线程（Thread）和进程（Process）是并发编程的两个基本构建块，它们都可以用来提高程序的执行效率。这里，我们分别介绍下这两个东西。

1、线程

线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位（一个进程中可以包含一个或者多个线程）。在Python中，线程是由threading模块提供的。线程具有如下特点：

轻量级：线程的创建和管理开销比进程小。
共享资源：同一进程内的线程共享进程的内存和资源，这使得线程间通信更高效，但也引入了线程安全问题。
上下文切换开销小：因为共享相同的内存空间，线程间的上下文切换比进程间的上下文切换开销小。
GIL限制：在CPython（Python的官方和最常用的实现）中，由于全局解释器锁（GIL）的存在，同一时间只有一个线程可以执行Python字节码，这限制了多线程的并行性。

多线程是指在同一个进程中并行执行多个线程，从而提高程序运行的效率。多线程的主要特点有：

使用threading模块可以创建多个线程，它们可以并行执行，共享进程的内存和资源。
多线程适用于I/O密集型任务，因为线程可以在等待I/O操作时让出CPU控制权，让其他线程运行。
需要处理好线程间的同步和互斥问题，避免竞态条件和死锁。

2、进程

进程是操作系统进行资源分配和调度的一个独立单位，它是应用程序运行的载体。在Python中，进程是由multiprocessing模块提供的。进程的主要特点有：

量级：进程的创建和管理开销比线程大。
独立资源：每个进程拥有独立的内存空间，进程间的通信需要通过特定的机制（如管道、共享内存等）。
无GIL限制：每个Python进程都可以独立地拥有一个解释器和内存空间，因此不受GIL的限制，可以实现真正的并行执行。

同样，多进程就是同时创建多个进程并行运行，主要特点是：

使用multiprocessing模块可以创建多个进程，它们可以并行执行，每个进程拥有独立的内存空间。
多进程适用于计算密集型任务，因为每个进程可以独立地使用CPU资源，实现真正的并行计算。
进程间的通信需要通过特定的机制，如Queue、Pipe等，这比线程间的通信更复杂。

二、理解线程/进程/协程

1、进程（Process） - 独立的餐厅厨房

我们可以想象一下，每个进程就像一个独立的餐厅厨房。每个厨房都有自己的一套完整的设备和厨师团队，可以独立地准备食物。当顾客下单时，每个厨房都可以同时为不同的顾客服务，互不干扰。

优点：互不干扰，一个厨房的问题不会直接影响到其他厨房。
缺点：资源占用多，每个厨房都需要一套完整的设备和人员，成本较高。

2、线程（Thread） - 共享厨房的厨师团队

在一个厨房内，线程就像一组共享厨房资源的厨师。他们共享所有的设备和材料，可以同时工作来准备不同的菜肴。但是，由于资源有限，如果多个厨师同时操作同一设备，就需要协调谁先谁后，否则可能会出现混乱。

优点：资源共享，节省成本，因为不需要每个团队都有自己的一套设备。
缺点：需要协调，如果管理不善可能会出现资源争抢（比如多个线程同时写入同一个数据库）。

3、协程（Coroutine） - 高效的厨师分工

协程可以看作是厨房里的一种高效工作方式。想象一位厨师在准备一道复杂的菜肴，需要经过多个步骤，每个步骤之间可能需要等待（比如等待水烧开）。在传统的线程（多厨师团队）模式中，这位厨师在等待时仍然占用着厨房资源。而协程模式下，这位厨师会在等待时主动让出厨房资源，去帮助其他厨师，等需要他继续工作时再回来。

优点：提高效率，通过在等待时让出资源，使得厨房可以处理更多的任务。
缺点：需要开发的程序员有良好的时间管理和任务调度能力。

三、python实现

1、多线程

下面，我们通过python代码来实现多线程。在下面的示例中，线程共享数据是通过一个在主线程中创建的列表results来实现的。这个列表被用作多个线程之间共享的数据结构，用于存储每个线程处理的结果。

每个线程在执行process_data函数时，会计算其分配的数据项的平方，并将结果写入results列表中对应的索引位置。例如，如果线程处理的数据项是data_list的第 i 个元素，那么它将计算结果存储在results[i]中。

但在更复杂的场景中，如果多个线程需要写入同一个列表元素或者在没有适当同步机制的情况下访问共享数据，就可能发生竞态条件。为了防止潜在的竞态条件和数据不一致问题，可以使用锁（例如threading.Lock）来同步对共享数据的访问。在写入共享数据之前获取锁，在写入完成后释放锁，可以确保在任何时刻只有一个线程能修改共享数据。

import threading  # 导入线程模块

def process_data(data, result_index, results, lock):
    """
    data (int): 要处理的数据。
    result_index (int): 结果存储的索引。
    results (list): 存储结果的列表。
    lock (threading.Lock): 用于同步访问结果列表的锁。
    """
    square = data * data  # 计算数据的平方
    with lock:  # 获取锁，确保对共享资源的访问是线程安全的
        results[result_index] = square  # 将结果存储在指定索引处
    print(f"Thread {threading.current_thread().name} processed {data}, result is {square}")

def start_threads(data_list, num_threads):
    """
    data_list (list): 要处理的数据列表。
    num_threads (int): 要启动的线程数。
    """
    results = [0] * len(data_list)  # 初始化结果列表，长度与数据列表相同
    lock = threading.Lock()  # 创建一个锁，用于同步访问结果列表
    threads = []  # 用于存储线程对象的列表

    for index, data in enumerate(data_list):
        # 创建一个线程来处理数据，并将线程对象添加到线程列表中
        thread = threading.Thread(target=process_data, args=(data, index, results, lock))
        threads.append(thread)
        thread.start()  # 启动线程

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

    return results  # 返回包含处理结果的列表

def main():
    """
    主函数，初始化数据列表并启动线程处理数据。
    """
    data_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  # 要处理的数据列表
    results = start_threads(data_list, 5)  # 启动线程处理数据
    print(f"Results: {results}")  # 打印处理结果

# 调用主函数
main()

# Thread Thread-16 processed 1, result is 1
# Thread Thread-17 processed 2, result is 4
# Thread Thread-18 processed 3, result is 9
# Thread Thread-19 processed 4, result is 16
# Thread Thread-20 processed 5, result is 25
# Thread Thread-21 processed 6, result is 36
# Thread Thread-22 processed 7, result is 49
# Thread Thread-23 processed 8, result is 64
# Thread Thread-24 processed 9, result is 81
# Thread Thread-25 processed 10, result is 100
# Results: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

2、多进程

下列代码实现多进程，需要注意的是，多进程任务中，进程之间的数据是不互通的，因此即便所有进程都拿到了一份原始数据的副本，则各个进程对副本的修改仅在该进程内有效。

import multiprocessing


def square(number):
    return number * number


def data_processor(data, result_queue):
    """
    处理数据的函数，计算每个数据的平方并将结果放入队列中。

    参数:
    data (list): 要处理的数据列表。
    result_queue (multiprocessing.Queue): 用于存储结果的队列。
    """
    result = []
    for number in data:
        result.append(square(number))
    result_queue.put(result)  # 将结果放入队列中
    print(f"Process {multiprocessing.current_process().name} calculated square of {number}: {result}")


def main():
    data = list(range(10))  # 数据列表
    processes = []
    result_queue = multiprocessing.Queue()  # 创建一个队列用于存储结果

    # 创建并启动子进程
    for i in range(0, len(data), 2):  # 每次处理2个数据
        process_data = data[i:i + 2]
        p = multiprocessing.Process(target=data_processor, args=(process_data, result_queue))
        processes.append(p)
        p.start()

    # 等待所有子进程完成
    for p in processes:
        p.join()

    # 收集所有子进程的结果
    results = []
    while not result_queue.empty():
        results.extend(result_queue.get())

    print(f"Results: {results}")


if __name__ == "__main__":
    main()

# Process Process-1 calculated square of 1: [0, 1]
# Process Process-2 calculated square of 3: [4, 9]
# Process Process-3 calculated square of 5: [16, 25]
# Process Process-4 calculated square of 7: [36, 49]
# Process Process-5 calculated square of 9: [64, 81]
# Results: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]