1
![进程地址空间独立](/assets/os-notes/Pasted%20image%2020260604201148.webp)
2

3
### 1.2 安全考虑
4

5
为了保证安全，**一个进程不能直接访问另一个进程的地址空间**。因此需要操作系统提供专门的通信机制。
6

7
### 1.3 IPC的三种方式
8

9
| 方式 | 原理 | 特点 |
10
|------|------|------|
11
| **共享存储** | 在内存中开辟共享区域 | 速度快，需要同步 |
12
| **消息传递** | 通过发送/接收消息 | 灵活，开销较大 |
13
| **管道通信** | 通过管道文件连接 | 简单，单向传输 |
14

15
---
16

17
<a id="共享存储"></a>
18
## 二、共享存储
19

20
### 2.1 基本原理
21

22
操作系统在内存中划出一块**共享存储区**，多个进程可以访问这块区域进行数据交换。
23

24
![共享存储](/assets/os-notes/Pasted%20image%2020260604201841.webp)
25

26
### 2.2 两种类型
27

28
| 类型 | 说明 | 特点 |
29
|------|------|------|
30
| **基于数据结构的共享** | 共享固定大小的数据结构（如数组） | 限制多、速度慢、**低级通信** |
31
| **基于存储区的共享** | 共享原始内存区域，数据形式由进程自定 | 灵活、速度快、**高级通信** |
32

33
### 2.3 同步互斥
34

35
多个进程访问共享空间时需要**互斥**，通常使用操作系统提供的同步互斥工具（如P、V操作、信号量）。
36

37
---
38

39
<a id="消息传递"></a>
40
## 三、消息传递
41

42
### 3.1 基本原理
43

44
进程间的数据交换以**格式化的消息**为单位，通过操作系统提供的"发送消息/接收消息"原语进行数据交换。
45

46
消息结构：

1
> **Linux方案**：一个管道允许**多个写进程**和**一个读进程**，或者**多个写进程**和**多个读进程**。
2

3
---
4

5
<a id="信号"></a>
6
## 五、信号
7

8
### 5.1 信号的概念
9

10
信号（Signal）是用于通知进程某个**特定事件已经发生**的机制。进程收到信号后进行相应处理。
11

12
### 5.2 信号的发送与保存
13

14
![信号发送](/assets/os-notes/Pasted%20image%2020260604211809.webp)
15

16
### 5.3 信号的处理时机
17

18
当进程从**内核态**转为**用户态**时，检查是否有待处理信号。
19

20
![信号处理时机](/assets/os-notes/Pasted%20image%2020260604212707.webp)
21

22
### 5.4 信号的处理方式
23

24
| 处理方式 | 说明 |
25
|----------|------|
26
| **默认处理** | 执行OS设置的缺省信号处理程序 |
27
| **自定义处理** | 用户注册的信号处理函数（覆盖默认） |
28
| **忽略** | 某些信号可以被忽略 |
29

30
### 5.5 信号处理规则
31

32
1. 处理完信号后，返回进程的下一条指令继续执行
33
2. 一旦处理了某个信号，pending位重置为0
34
3. 重复收到的同类信号被丢弃
35
4. 同时收到多个信号时，先处理序号更小的
36
5. 某些信号不能被自定义处理或阻塞（如SIGKILL、SIGSTOP）
37

38
---
39

40
<a id="linux"></a>
41
## 六、Linux实战：进程通信
42

43
### 6.1 管道通信
44

45
```bash
46
# 匿名管道（父子进程间）
47
ls | grep ".txt"
48

49
# 创建命名管道（任意进程间）
50
mkfifo /tmp/my_pipe
51

52
# 写入端
53
echo "Hello from writer" > /tmp/my_pipe &
54

55
# 读取端
56
cat /tmp/my_pipe

1
# 使用ipcs查看共享内存
2
ipcs -m
3

4
# Python共享内存示例
5
python3 << 'EOF'
6
import multiprocessing
7
import time
8

9
def writer(shm):
10
    shm.buf[:5] = b'Hello'
11
    print("写入完成")
12

13
def reader(shm):
14
    time.sleep(1)
15
    print(f"读取: {bytes(shm.buf[:5])}")
16

17
if __name__ == '__main__':
18
    shm = multiprocessing.shared_memory.SharedMemory(create=True, size=1024)
19

20
    p1 = multiprocessing.Process(target=writer, args=(shm,))
21
    p2 = multiprocessing.Process(target=reader, args=(shm,))
22

23
    p1.start()
24
    p2.start()
25
    p1.join()
26
    p2.join()
27

28
    shm.close()
29
    shm.unlink()
30
EOF

1
# 查看消息队列
2
ipcs -q
3

4
# Python消息队列示例
5
python3 << 'EOF'
6
from multiprocessing import Queue, Process
7

8
def sender(q):
9
    q.put("Hello from sender")
10
    q.put(42)
11

12
def receiver(q):
13
    print(f"收到: {q.get()}")
14
    print(f"收到: {q.get()}")
15

16
if __name__ == '__main__':
17
    q = Queue()
18
    p1 = Process(target=sender, args=(q,))
19
    p2 = Process(target=receiver, args=(q,))
20
    p1.start()
21
    p1.join()
22
    p2.start()
23
    p2.join()
24
EOF

1
# 查看所有信号
2
kill -l
3

4
# 发送信号
5
kill -SIGUSR1 <PID>    # 发送用户自定义信号
6
kill -SIGTERM <PID>    # 请求终止
7
kill -SIGKILL <PID>    # 强制终止
8

9
# Python信号处理
10
python3 << 'EOF'
11
import signal
12
import os
13

14
def handler(signum, frame):
15
    print(f"收到信号 {signum}")
16

17
signal.signal(signal.SIGUSR1, handler)
18

19
print(f"PID: {os.getpid()}")
20
print("等待信号 SIGUSR1...")
21
signal.pause()
22
EOF

1
# 服务器端
2
python3 -c "
3
import socket
4
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
5
s.bind(('localhost', 12345))
6
s.listen(1)
7
conn, addr = s.accept()
8
data = conn.recv(1024)
9
print(f'收到: {data.decode()}')
10
conn.send(b'Hello from server')
11
conn.close()
12
" &
13

14
# 客户端
15
python3 -c "
16
import socket
17
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
18
s.connect(('localhost', 12345))
19
s.send(b'Hello from client')
20
data = s.recv(1024)
21
print(f'收到: {data.decode()}')
22
s.close()
23
"