进程与进程间通信

一、计算机中的关键概念

在计算机科学中，进程是指正在运行的程序的实例。每个进程都拥有自己的内存空间、数据、代码和系统资源。进程是操作系统中的关键概念，它使得计算机可以同时运行多个程序，并且确保它们彼此独立运行。

二、进程的特点

1. 独立性：每个进程都拥有独立的内存空间和资源，使得它们不会相互干扰。

# 独立性示例
import multiprocessing

# 定义一个函数作为进程的执行内容
def print_message(message):
    print(message)

if __name__ == "__main__":
    # 创建并启动两个独立的进程
    p1 = multiprocessing.Process(target=print_message, args=("Process 1: I'm independent",))
    p2 = multiprocessing.Process(target=print_message, args=("Process 2: I'm also independent",))
    p1.start()    # Process 1: I'm independent
    p2.start()    # Process 2: I'm also independent

2. 并发性：操作系统可以在多个进程之间快速切换，实现看起来同时运行的效果。

# 并发性示例
import multiprocessing
import time

# 定义一个函数作为进程的执行内容
def count_numbers():
    for i in range(1, 6):
        print(i)
        time.sleep(1)

if __name__ == "__main__":
    # 创建并启动一个进程
    p = multiprocessing.Process(target=count_numbers)
    p.start()

    # 主进程继续执行其他任务
    for i in range(6, 11):
        print(i)
        time.sleep(1)

# 结果：16273849510
#子进程和父进程是并发执行的，因此在输出结果时可能会出现顺序上的不确定性，输出的顺序可能会受到系统调度的影响。

3. 隔离性：进程之间的数据和资源是相互隔离的，从而提高了系统的稳定性和安全性。

# 隔离性示例
import multiprocessing

# 定义一个函数作为进程的执行内容
def update_global_dict(key, value):
    global_dict[key] = value

if __name__ == "__main__":
    # 创建一个全局字典
    global_dict = {}

    # 创建并启动一个进程来更新全局字典
    p = multiprocessing.Process(target=update_global_dict, args=("key", "value"))
    p.start()
    p.join()  # 等待子进程结束
  
    print(global_dict)       # 主进程输出全局字典的值，应该为空，证明进程间数据是相互隔离的

三、进程的管理

操作系统通过进程管理来控制和协调各个进程的运行。它负责分配系统资源、调度进程、以及处理进程之间的通信和同步。

进程的状态

1. 就绪状态：进程已经准备好运行，等待系统分配资源。
2. 运行状态：进程正在执行指令。
3. 阻塞状态：进程因为某些原因暂时无法继续执行，例如等待输入或输出。
4. 终止状态：进程执行完毕并结束。

import multiprocessing
import time

# 模拟客户端请求处理函数
def handle_client_request(client_id):
    print(f"Processing request from client {client_id}")
    time.sleep(3)  # 模拟处理请求的耗时操作
    print(f"Request from client {client_id} processed")

if __name__ == "__main__":
    # 模拟多个客户端连接
    client_ids = [1, 2, 3, 4, 5]

    # 创建并启动进程来处理客户端请求
    for client_id in client_ids:
        p = multiprocessing.Process(target=handle_client_request, args=(client_id,))
        p.start()


# 一个多进程的网络服务器原理如下：

# 主程序模拟多个客户端连接，每个客户端对应一个请求处理函数的调用。
# 主程序为每个客户端请求创建一个新的进程来处理，进程经历就绪、运行和终止状态。
# 进程执行请求处理逻辑，可能进入阻塞状态，完成后重新进入就绪状态等待系统分配资源。

进程间通信

进程之间可以通过各种方式进行通信，包括共享内存、消息传递、管道等。这些机制使得不同进程之间可以进行数据交换和协作，实现更复杂的任务和功能。

1.共享内存：

原理是将数据存储在系统分配的共享内存中，不同进程可以直接访问这块内存区域，实现数据共享和通信。Python中，可以使用multiprocessing.Value或multiprocessing.Array来创建共享内存变量，进程可以通过这些变量进行数据交换。。

import multiprocessing

# 共享内存通信示例
def update_shared_value(shared_value):
    shared_value.value += 1  # 在共享内存中增加值

if __name__ == "__main__":
    # 创建共享内存
    shared_value = multiprocessing.Value('i', 0)

    # 创建并启动一个进程来更新共享内存
    p = multiprocessing.Process(target=update_shared_value, args=(shared_value,))
    p.start()
    p.join()  # 等待子进程结束

    # 输出共享内存的值
    print("Shared value:", shared_value.value)

2.消息传递：

这种方法的原理是利用队列或管道作为中介，一个进程将数据放入队列或管道，另一个进程则从中取出数据，实现了数据传递和通信。

import multiprocessing

# 通过队列进行进程间通信示例
def sender(q):
    message = "Hello from sender"
    q.put(message)  # 将消息放入队列

def receiver(q):
    message = q.get()  # 从队列中获取消息
    print("Received message:", message)

if __name__ == "__main__":
    # 创建一个队列
    q = multiprocessing.Queue()

    # 创建并启动发送和接收进程
    sender_process = multiprocessing.Process(target=sender, args=(q,))
    receiver_process = multiprocessing.Process(target=receiver, args=(q))
    sender_process.start()
    receiver_process.start()
    sender_process.join()
    receiver_process.join()

3.管道：

管道是一种特殊的进程间通信机制，在Python中可以使用multiprocessing.Pipe来创建管道。管道实际上是由操作系统提供的一种通信机制，它在内存中创建一个缓冲区，通过这个缓冲区进行进程间的通信。其中，multiprocessing.Pipe创建了一对连接的管道端点，每个端点都对应一个进程。一个进程可以向管道写入数据，另一个进程则可以从中读取数据，实现了双向通信。

import multiprocessing

# 通过管道进行进程间通信示例
def sender(pipe):
    message = "Hello from sender"
    pipe.send(message)  # 发送消息通过管道

def receiver(pipe):
    message = pipe.recv()  # 从管道接收消息
    print("Received message:", message)

if __name__ == "__main__":
    # 创建一个管道
    parent_conn, child_conn = multiprocessing.Pipe()

    # 创建并启动发送和接收进程
    sender_process = multiprocessing.Process(target=sender, args=(parent_conn,))
    receiver_process = multiprocessing.Process(target=receiver, args=(child_conn,))
    sender_process.start()
    receiver_process.start()
    sender_process.join()
    receiver_process.join()