Python的多进程与多线程

全局解释器锁（GIL）

作用：GIL确保任何时候只有一个线程执行Python代码。这是为了保护Python内存管理机制（如引用计数）的一致性。

影响：尽管现代计算机可能有多个核心，但在 CPython 中，由于 GIL 的存在，多线程程序可能不会在多核上并行执行。这意味着，如果你的程序主要是计算密集型的，使用多线程可能不会带来性能上的提升。

线程安全

问题：当两个或更多的线程访问同一个数据时，如果没有适当的锁定机制，可能会导致数据损坏或不可预测的结果。

解决方案：使用 threading.Lock() 创建一个锁对象。线程在修改共享数据之前必须先获得锁，修改后再释放锁。例如：

import threading

class BankAccount:
    def __init__(self, balance=0):
        self.balance = balance
        # 初始化锁
        self.lock = threading.Lock()
        
    def deposit(self, amount):
        with self.lock:
            print(f"Depositing {amount} to the account")
            threading.sleep(1)
            self.balance += amount
            print(f"New balance is {self.balance}")
            
    def withdraw(self,amount):
        with self.lock:
            if self.balance >= amount:
                print(f"Withdrawing {amount} from the account")
                threading.sleep(1)
                self.balance -= amount
                print(f"New balance is {self.balance}")
            else:
                print("Insufficient funds")
            
# 创建银行账户实例
account = BankAccount(1000)  # 初始余额为1000           
            
            
# 定义存款和取款的线程任务
def task_deposit(account, amount):
    account.deposit(amount)

def task_withdraw(account, amount):
    account.withdraw(amount)

# 创建并启动多个存款和取款线程
deposit_thread = threading.Thread(target=task_deposit, args=(account, 500))
withdraw_thread = threading.Thread(target=task_withdraw, args=(account, 300))

deposit_thread.start()
withdraw_thread.start()

# 等待所有线程完成
deposit_thread.join()
withdraw_thread.join()            
            
            

锁的实例化，每个BankAccount实例都有自己的锁，这意味着我们可以为不同的账户创建不同的线程，而它们的操作不会互相干扰。

通过使用 with self.lock: 语句，确保了存款和取款操作在任何时候只由一个线程执行，从而避免了竞态条件。

多线程的使用场景

I/O 密集型任务：如果你的程序大部分时间在等待 I/O 操作（如网络响应、磁盘读写），多线程可以提高性能。因为一个线程等待 I/O 时，其他线程可以继续执行。

多进程

Python 的 multiprocessing 模块：这个模块允许你创建进程，每个进程有自己的 Python 解释器和内存空间，因此不受 GIL 的限制。

优点：每个进程可以独立地运行在不同的 CPU 核心上，适合 CPU 密集型任务。

示例代码：

from multiprocessing import Process

def cpu_intensive_task():
    # 这里执行一些计算密集型任务
    pass

if __name__ == "__main__":
    # 创建进程
    p = Process(target=cpu_intensive_task)
    p.start()  # 启动进程
    p.join()   # 等待进程结束

总结一下两者的不同点：

• 多线程：适用于 I/O 密集型任务，可以提高程序响应性，但受 GIL 限制，在 CPython 中不会实现真正的并行执行。

• 多进程：适用于 CPU 密集型任务，可以绕过 GIL，实现真正的并行执行，但进程间通信和同步比线程复杂。

还有一些关键的区别

1、资源和内存使用

多进程：每个进程都有独立的内存空间和系统资源。进程间相互独立，一个进程的崩溃不会直接影响其他进程。

多线程：线程共享所需进程的内存空间和资源。线程的创建和切换开销小，但需要协调对共享内存的访问。

2、创建和管理开销

多进程：创建进程需要更多的时间和资源，因为操作系统需要分配独立的内存和资源。

多线程：线程的创建和管理开销较小，因为它们共享同一进程的资源。

3、通信方式

多进程：进程间通信（IPC）通常通过消息传递、管道、共享内存、套接字等方式实现。

多线程：线程间可以直接访问共享数据，通信更简单，但需要同步机制来避免竞态条

4、全局解释器锁（GIL）

多进程：不受 Python 的 GIL 限制，每个进程可以独立地执行在不同的 CPU 核心上。

多线程：在 CPython 中，由于 GIL 的存在，同一时刻只有一个线程可以执行 Python 字节码，这限制了多线程的并行性。

5、数据隔离

多进程：进程间数据天然隔离，数据共享需要显式地通过 IPC 机制。

多线程：线程间可以更容易地共享数据，但需要特别注意线程安全。