详解Python中的进程和线程

详解Python中的进程和线程

在Python中，进程和线程都是用来实现多任务编程的机制。但是它们之间有着很大的区别，下面我们就来详细讲解Python中的进程和线程。

进程

进程是操作系统中进行资源分配和调度的基本单位。每一个进程都有自己独立的内存空间，不同进程之间互相独立运行，互不干扰。Python通过os模块提供的fork()函数来创建进程，如下所示：

import os

pid = os.fork()

if pid == 0:
    print("子进程，pid:", os.getpid())
else:
    print("父进程，pid:", os.getpid(), "子进程pid:", pid)

以上代码中，os.fork()会返回两次，分别在父进程和子进程中，因此可以通过返回值的不同来区分父子进程。执行以上代码，可以得到如下输出结果：

父进程，pid: 123 子进程pid: 124
子进程，pid: 124

可以看到，父进程和子进程的PID不同，证明了创建了一个新的进程。

线程

线程是进程中的一个执行流，是CPU调度和分配的基本单位，它比进程更轻量级。多个线程可以共享进程的内存空间，且它们之间可以互相通信。Python中的线程通过threading模块来实现，如下所示：

import threading
import time

def worker():
    print("开始执行工作")
    time.sleep(3)   # 暂停3秒，模拟工作执行时间
    print("工作执行完毕")

t = threading.Thread(target=worker)
t.start()

以上代码中，通过创建threading.Thread对象，并传入工作函数，即可创建一个线程。执行以上代码，可以得到如下输出结果：

开始执行工作
工作执行完毕

可以看到，线程先输出了“开始执行工作”，然后暂停了3秒钟，最终输出了“工作执行完毕”。

进程与线程的区别

进程和线程虽然都可以实现多任务编程，但是它们之间的区别很大：

• 进程是由操作系统进行调度和管理，线程是由程序自己控制的。
• 进程有独立的内存空间，不同进程之间互不干扰；线程共享进程的内存空间。
• 进程的创建和销毁需要系统调用，开销较大；线程的创建和销毁相对较小。
• 进程切换需要保存和恢复整个上下文环境，代价较大；线程切换代价相对较小。

因此，在进行多任务编程时，如果需要更多的资源隔离和安全性，建议使用进程；如果需要更高的性能和更快的响应速度，建议使用线程。

总结

以上就是Python中进程和线程的详细讲解。无论是使用进程还是线程，我们都需要注意线程之间的数据共享和访问控制问题，同时还要避免死锁、竞争等多线程编程的常见问题。

下面再分别举两个例子，说明Python中如何操作进程和线程：

进程示例

以下代码演示如何使用Python的multiprocessing模块来开启多个进程，计算每个进程中的整数和，并汇总结果：

import multiprocessing

def calcSum(start, end):
    sum = 0
    for i in range(start, end+1):
        sum += i
    return sum

if __name__ == '__main__':
    pool = multiprocessing.Pool(processes=4)
    results = []
    for i in range(4):
        results.append(pool.apply_async(calcSum, (1+i*25, (i+1)*25)))
    pool.close()
    pool.join()

    final_result = sum([r.get() for r in results])
    print(final_result)

以上代码中，我们使用multiprocessing.Pool对象来创建进程池，然后使用apply_async方法来开启多个进程并运行calcSum函数。最终将各个进程计算结果汇总即可。

线程示例

以下代码使用Python的threading模块开启多个线程，模拟各个线程之间的竞争情况。

import threading

n = 0
lock = threading.Lock()

def work():
    global n
    lock.acquire()
    for i in range(100000):
        n += 1
    lock.release()

threads = []
for i in range(10):
    t = threading.Thread(target=work)
    t.start()
    threads.append(t)

for t in threads:
    t.join()

print(n)

以上代码中我们创建了10个线程，并且使用了lock对象来进行访问控制，以此保证计数器n的并发访问安全。最终结果应该是n的值为1000000。