1322 字

7 分钟

进程和线程间的通信方式

2025-12-11

进程间通信（IPC，Inter-Process Communication） 和 线程间通信（Thread Communication） 是多任务编程中两种常见的通信方式。它们的主要区别在于，进程之间有独立的内存空间，而线程之间共享同一进程的内存空间。因此，通信方式也有所不同。

一、进程间通信（IPC）#

由于进程之间内存空间是独立的，因此需要特殊的机制来交换数据。常见的进程间通信方式包括：

1. 管道（Pipes）#

匿名管道（Unnamed Pipes）：用于父子进程之间的通信，数据只能在父子进程之间单向传递。

命名管道（Named Pipes）：允许在任意两个进程间进行通信，管道通过名称标识。

示例（Python 使用 os.pipe）：

1
import os
2
r, w = os.pipe()
3
os.write(w, b"Hello from the parent process")
4
print(os.read(r, 1024))  # 输出：b'Hello from the parent process'

2. 消息队列（Message Queues）#

通过消息队列，进程可以将消息发送到队列中，其他进程从队列中读取消息。消息队列提供了进程间的一种同步机制。

示例（Python 使用 multiprocessing.Queue）：

1
from multiprocessing import Process, Queue
2

3
def worker(q):
4
  q.put("Hello from the child process")
5

6
if __name__ == "__main__":
7
  q = Queue()
8
  p = Process(target=worker, args=(q,))
9
  p.start()
10
  print(q.get())  # 输出：Hello from the child process
11
  p.join()

3. 共享内存（Shared Memory）#

通过共享内存，多个进程可以访问同一块内存区域。常用于高效传递大量数据。示例（Python 使用 multiprocessing.Value 或 Array）：

1
from multiprocessing import Process, Value
2

3
def worker(num):
4
    num.value = 42
5

6
if __name__ == "__main__":
7
    shared_num = Value('i', 0)
8
    p = Process(target=worker, args=(shared_num,))
9
    p.start()
10
    p.join()
11
    print(shared_num.value)  # 输出：42

4. 信号（Signals）#

进程可以发送信号给其他进程来通知某些事件发生。例如，SIGINT 信号用于终止进程。

5. 套接字（Sockets）#

进程可以通过套接字进行通信，无论它们是否在同一台机器上。套接字支持网络通信，可以在不同机器的进程之间进行通信。示例（Python 使用 socket）：

1
import socket
2

3
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
4
server.bind(('localhost', 12345))
5
server.listen(1)
6
client, addr = server.accept()
7
client.send(b"Hello from server")
8
client.close()

6. 文件映射（Memory-Mapped Files）#

进程通过共享内存映射文件，来访问文件内容。这种方式对于处理大量数据时非常高效。

二、线程间通信#

线程共享同一进程的内存空间，因此线程间的通信要比进程间通信更简单。常见的线程间通信方式包括：

1. 共享变量（Shared Variables）#

线程可以直接访问全局变量或共享的数据结构。由于多个线程共享同一内存区域，因此访问共享数据时必须保证线程安全，避免数据竞争。示例：

1
import threading
2

3
shared_data = 0
4

5
def worker():
6
    global shared_data
7
    shared_data += 1
8

9
threads = []
10
for _ in range(10):
11
    t = threading.Thread(target=worker)
12
    threads.append(t)
13
    t.start()
14

15
for t in threads:
16
    t.join()
17

18
print(shared_data)  # 输出：10

在这种情况下，可能需要使用锁来确保线程安全。

2. 锁（Locks）#

使用锁（如 threading.Lock）来确保对共享资源的互斥访问。当一个线程获得锁时，其他线程必须等待。示例：

1
import threading
2

3
shared_data = 0
4
lock = threading.Lock()
5

6
def worker():
7
    global shared_data
8
    with lock:
9
        shared_data += 1
10

11
threads = []
12
for _ in range(10):
13
    t = threading.Thread(target=worker)
14
    threads.append(t)
15
    t.start()
16

17
for t in threads:
18
    t.join()
19

20
print(shared_data)  # 输出：10

3. 事件（Events）#

线程可以使用事件（如 threading.Event）来通知其他线程某个操作已完成或某个条件已满足。事件对象允许线程等待直到某个条件被触发。示例：

1
import threading
2

3
event = threading.Event()
4

5
def worker():
6
    print("Worker waiting for event")
7
    event.wait()  # 等待事件触发
8
    print("Worker received event")
9

10
t = threading.Thread(target=worker)
11
t.start()
12

13
event.set()  # 触发事件
14
t.join()

4. 队列（Queues）#

queue.Queue 提供了线程安全的队列。一个线程可以将数据放入队列中，另一个线程可以从队列中取出数据。队列在多线程编程中用于线程间的通信和数据传递。示例：

1
import threading
2
import queue
3

4
q = queue.Queue()
5

6
def worker():
7
    q.put("Hello from the worker thread")
8

9
t = threading.Thread(target=worker)
10
t.start()
11
print(q.get())  # 输出：Hello from the worker thread
12
t.join()

5. 条件变量（Condition Variables）#

条件变量（threading.Condition）用于协调线程之间的执行。线程可以在某些条件下被通知，通常用于生产者消费者问题。示例：

1
import threading
2

3
condition = threading.Condition()
4
shared_data = []
5

6
def producer():
7
    with condition:
8
        shared_data.append(1)
9
        condition.notify()  # 通知消费者
10

11
def consumer():
12
    with condition:
13
        while not shared_data:
14
            condition.wait()  # 等待数据
15
        print(f"Consumed: {shared_data.pop()}")
16

17
threading.Thread(target=producer).start()
18
threading.Thread(target=consumer).start()

三、总结：进程间通信与线程间通信的主要区别#

特性	进程间通信（IPC）	线程间通信
内存空间	进程有独立的内存空间，数据不共享	线程共享同一进程的内存空间
通信方式	管道、消息队列、共享内存、信号、套接字、文件映射等	共享变量、锁、事件、队列、条件变量等
开销	进程间通信通常开销较大，需通过操作系统提供的机制	线程间通信开销较小，直接通过共享内存进行通信
适用场景	多进程应用（如分布式系统）	多线程应用（如并发 I/O、任务分解等）
数据共享	进程不共享数据，需要通过 IPC 进行通信	线程共享数据，但需使用同步机制避免竞争条件