2022_09_14-Aet

Bingliaolong 2022-09-26 16:27 Aet | 隐藏边栏 | 抢沙发 | 18 0

文章评分 2 次，平均分 5.0 ：

智能指针

进程间通信

共享内存

让两个进程的虚拟地址空间映射到同一组物理内存页

进程 A 虚拟地址 ─┐

├── 同一块物理内存

进程 B 虚拟地址 ─┘

Linux
1. POSIX：shm_open + ftruncate + mmap
2. System V：shmget + shmat
3. 匿名共享映射：mmap(..., MAP_SHARED, ...)
4. 普通文件映射：mmap
windows
1. CreateFileMapping
2. OpenFileMapping
3. MapViewOfFile

无名管道

无名管道是一段由内核维护的字节流缓冲区

1	进程 A ──write──> 内核管道缓冲区 ──read──> 进程 B

linux
1. 通常先创建管道，再调用 fork()
2. 父子进程会继承文件描述符，因此天然适合父子进程通信

int fd[2];

pipe(fd);

// fd[0]：读端

// fd[1]：写端

父进程创建 pipe

↓

fork

↙ ↘

父进程子进程

写 fd[1] 读 fd[0]

windows
1. 通过句柄继承把管道句柄传递给子进程

1	CreatePipe(...)

有名管道

有名管道拥有一个可供独立进程找到的名字，因此通信双方不需要有父子关系
Linux FIFO
1. Linux FIFO 本质上仍然是字节流

mkfifo("/tmp/my_fifo", 0666);

int fd = open("/tmp/my_fifo", O_WRONLY);

write(fd, data, size);

1 2	int fd = open("/tmp/my_fifo", O_RDONLY); read(fd, buffer, size);

Windows Named Pipe
1. Windows 有名管道功能更强，可以：
2. 单向或双向通信
3. 字节模式或消息模式
4. 支持多个客户端实例
5. 配合重叠 I/O 和 IOCP
6. 在适当配置下支持网络访问

CreateNamedPipe(

R"(\\.\pipe\MyPipe)",

...);

CreateFile(

R"(\\.\pipe\MyPipe)",

...);

消息队列

消息队列由内核维护。发送方提交完整消息，接收方按消息取出

进程 A ──消息1──┐

进程 B ──消息2──┼──> 内核消息队列 ──> 进程 C

进程 D ──消息3──┘

与管道的重要区别：
1. 管道：连续字节流，没有天然消息边界
2. 消息队列：一条一条的消息，有消息边界
linux System V 消息队列
1. 消息可以带类型：

msgget();

msgsnd();

msgrcv();

msgctl();

struct Message {

long type;

char data[128];

};

POSIX 消息队列
1. POSIX 消息队列支持消息优先级

mq_open();

mq_send();

mq_receive();

mq_close();

mq_unlink();

windows
1. Windows 没有与 POSIX/System V 完全对应的通用内核消息队列 API
工程中常见组合：
1. 消息队列：传递控制消息和共享内存索引
2. 共享内存：保存真正的大块数据

`socket`

通用的双向通信接口

`rpc`

远程过程调用，它不是一种与 Socket 完全平级的底层通信方式
RPC 的目标是让跨进程调用看起来接近普通函数调用
示例

1	User user = get_user(1001);

客户端调用 get_user(1001)

↓

序列化：函数名、参数

↓

Named Pipe / Socket / 共享内存

↓

服务端反序列化

↓

执行真正的 get_user

↓

序列化返回值

↓

客户端反序列化得到 User

`com`

跨进程时，可以用代理、存根服务器通信

`DCOM`

DCOM 将 COM 调用扩展到不同机器

进程间同步

事件

某件事情发生了，等待者可以继续执行

HANDLE event = CreateEvent(

nullptr,

FALSE, // 自动重置

FALSE, // 初始无信号

nullptr);

1	WaitForSingleObject(event, INFINITE);

1	SetEvent(event);

Windows 事件有两种
1. 自动重置事件：唤醒一个等待者后，自动恢复为无信号状态
2. 手动重置事件：保持有信号状态，可以唤醒所有等待者，直到调用

1	ResetEvent(event);

linux
1. Linux 没有一个与 Windows Event 完全相同的通用对象
2. 常用替代方式：
3. eventfd
4. 条件变量
5. 信号量
6. 管道
7. futex
8. signalfd

互斥量

同一时刻，只允许一个执行者进入临界区

1 2	进程 A 获得锁 → 修改共享数据 → 释放锁进程 B 等待 ─────────────────→ 获得锁

windows
1. 命名 Mutex 可以在多个进程之间打开

CreateMutex();

OpenMutex();

WaitForSingleObject();

ReleaseMutex();

1	CreateMutex(nullptr, FALSE, L"Global\\MyMutex");

linux
1. 普通 pthread_mutex_t 默认只在线程间使用
2. 要跨进程，需要把互斥量放在共享内存中，并设置：
3. 还可以使用 robust mutex，使持锁进程崩溃后，其他进程能够检测

pthread_mutexattr_setpshared(

&attr,

PTHREAD_PROCESS_SHARED);

pthread_mutexattr_setrobust(

&attr,

PTHREAD_MUTEX_ROBUST);

信号量

信号量本质上是一个计数器

计数 > 0：等待者可以获得一个资源，计数减一

计数 = 0：等待者阻塞

释放资源：计数加一并可能唤醒等待者

如果初始化为3，表示最多允许3个执行者同时进入

资源数量 = 3

进程 A：占用一个

进程 B：占用一个

进程 C：占用一个

进程 D：等待

Windows

CreateSemaphore();

OpenSemaphore();

WaitForSingleObject();

ReleaseSemaphore();

Linux POSIX
1. 第二个参数为1表示进程间共享，但信号量对象本身必须位于共享内存

// 匿名进程共享信号量

sem_init(&sem, 1, initial_value);

// 命名信号量

sem_open();

sem_wait();

sem_post();

sem_close();

sem_unlink();

条件变量

等待某个受互斥量保护的条件成立

while (queue.empty()) {

pthread_cond_wait(&condition, &mutex);

}

queue.push(data);

pthread_cond_signal(&condition);

跨进程使用时，条件变量和互斥量都必须放在共享内存中，并设置：

pthread_condattr_setpshared(

&attr,

PTHREAD_PROCESS_SHARED);

文件锁

多个进程通过文件交换数据时，可以使用文件锁
linux

1 2	flock(); fcntl();

windows

LockFile();

LockFileEx();

UnlockFile();

`COM`的使用

介绍

COM定义了标准线路格式和协议，以便在不同硬件平台上运行的对象之间进行交互
COM与实现语言无关，可以使用不同的编程语言来创建COM库

概念

接口
1. 成员函数的集合，面向对象中接口类
IID
1. 每个接口都有自己的唯一接口标识符IID，IID是一个全局唯一标识符GUID，IID只会对应一个接口
COM类
1. COM类可以创建实现了多个接口
GLSID
1. 每个com 类都有一个CLSID，在windows 上com 类的实现在 dll 或者 exe 上
映射关系
1. COM 维护系统上安装的 COM 对象的所有 Clsid 的注册数据库
2. 注册数据库是每个 CLSID 之间的映射，以及承载相应类的 DLL 或 EXE 的位置。
3. 每当调用方想要创建 COM 类的实例时，COM 都将查询此数据库
4. 调用方只需了解用于请求类的新实例的 CLSID

`CoCreateInstance`

根据 CLSID 找到 COM 类的“类工厂”
让类工厂创建对象
再返回调用者指定的接口指针

客户端线程

↓

确认 COM 已初始化

↓

根据 CLSID 查找 COM 类注册信息

↓

定位 DLL、EXE 或其他激活信息

↓

获得 IClassFactory

↓

调用 IClassFactory::CreateInstance

↓

创建 COM 对象

↓

获得请求的 IID 对应接口

↓

把接口指针返回给客户端

临界区

概述

临界区不是某块特殊内存，而是一段访问共享资源、需要互斥执行的代码

`Windows` `CRITICAL_SECTION`

InitializeCriticalSection

↓

EnterCriticalSection

↓

访问共享资源

↓

LeaveCriticalSection

↓

DeleteCriticalSection

进入临界区时发生什么

如果没有其他线程持有：
1. 立即获得临界区，继续执行
如果已经被其他线程持有：

当前线程等待

↓

持有线程调用 LeaveCriticalSection

↓

等待线程获得临界区

工程中如果不依赖 Windows 专用 API，通常优先使用标准 C++

#include <mutex>

std::mutex g_mutex;

int g_counter = 0;

void update_counter() {

std::lock_guard<std::mutex> lock{g_mutex};

++g_counter;

}

void update_counter() {

std::scoped_lock lock{g_mutex};

++g_counter;

}

从DLL中找函数的地址

在 Windows 中，从 DLL 查找函数地址的标准流程是：

1	LoadLibrary → GetProcAddress → 调用函数 → FreeLibrary

GetProcAddress 做了什么

MyDll.dll 映射到当前进程地址空间

↓

找到 PE 导出表

↓

按名称查找 "add"

↓

返回函数入口地址

查看DLL中的函数

在 Windows 下，要“查看 DLL 中有哪些函数”，本质上是查看 DLL 的 PE 导出表
枚举全部导出函数需要自己解析 PE 导出表，或者使用 dumpbin、Dependencies 等工具

编码

反转链表

#include <iostream>

struct ListNode {

int value;

ListNode* next;

};

ListNode* reverse_list(ListNode* head) {

ListNode* prev = nullptr;

ListNode* current = head;

while (current != nullptr) {

// 1. 保存下一个节点，避免修改指针后丢失后续链表

ListNode* next = current->next;

// 2. 反转当前节点的指向

current->next = prev;

// 3. 两个指针向后移动

prev = current;

current = next;

}

// current 已经指向 nullptr，prev 是新的头节点

return prev;

}

ListNode* reverse_list_recursive(ListNode* head) {

if (head == nullptr || head->next == nullptr) {

return head;

}

ListNode* new_head =

reverse_list_recursive(head->next);

head->next->next = head;

head->next = nullptr;

return new_head;

}

单链表排序

#include <iostream>

struct ListNode {

int value;

ListNode* next;

};

// 合并两个有序链表

ListNode* merge_sorted_lists(ListNode* lhs, ListNode* rhs) {

// 临时头节点，避免单独处理结果链表的第一个节点

ListNode dummy{0, nullptr};

ListNode* tail = &dummy;

while (lhs != nullptr && rhs != nullptr) {

if (lhs->value <= rhs->value) {

tail->next = lhs;

lhs = lhs->next;

} else {

tail->next = rhs;

rhs = rhs->next;

}

tail = tail->next;

}

// 其中一个链表已经用完，接上另一个链表的剩余部分

tail->next = lhs != nullptr ? lhs : rhs;

return dummy.next;

}

// 使用归并排序对单链表排序

ListNode* sort_list(ListNode* head) {

// 空链表或只有一个节点时，天然有序

if (head == nullptr || head->next == nullptr) {

return head;

}

// 快慢指针寻找链表中点

ListNode* slow = head;

ListNode* fast = head->next;

while (fast != nullptr && fast->next != nullptr) {

slow = slow->next;

fast = fast->next->next;

}

// 从 slow 后面断开，得到两个独立链表

ListNode* right_head = slow->next;

slow->next = nullptr;

ListNode* left = sort_list(head);

ListNode* right = sort_list(right_head);

return merge_sorted_lists(left, right);

}

void print_list(const ListNode* head) {

while (head != nullptr) {

std::cout << head->value;

if (head->next != nullptr) {

std::cout << " -> ";

}

head = head->next;

}

std::cout << '\n';

}

int main() {

ListNode node5{2, nullptr};

ListNode node4{4, &node5};

ListNode node3{1, &node4};

ListNode node2{3, &node3};

ListNode node1{5, &node2};

ListNode* head = &node1;

std::cout << "排序前：";

print_list(head);

head = sort_list(head);

std::cout << "排序后：";

print_list(head);

}

智能指针
进程间通信
共享内存
无名管道
有名管道
消息队列
socket
rpc
com
DCOM
进程间同步
事件
互斥量
信号量
条件变量
文件锁
COM的使用
介绍
概念
CoCreateInstance
临界区
概述
Windows CRITICAL_SECTION
进入临界区时发生什么
从DLL中找函数的地址
查看DLL中的函数
编码
反转链表
单链表排序

声明：本文为原创文章，版权归Aet所有，欢迎分享本文，转载请保留出处！

Bingliaolong 关注：0 粉丝：0 最后编辑于：2026-07-28

Everything will be better.

一	二	三	四	五	六	日
				1	2	3
4	5	6	7	8	9	10
11	12	13	14	15	16	17
18	19	20	21	22	23	24
25	26	27	28	29	30	31

智能指针

进程间通信

共享内存

无名管道

有名管道

消息队列

`socket`

`rpc`

`com`

`DCOM`

进程间同步

事件

互斥量

信号量

条件变量

文件锁

`COM`的使用

介绍

概念

`CoCreateInstance`

临界区

概述

`Windows` `CRITICAL_SECTION`

进入临界区时发生什么

从DLL中找函数的地址

查看DLL中的函数

编码

反转链表

单链表排序

你可能也喜欢

热评文章

发表评论

标签云集

2022_09_14

智能指针

进程间通信

共享内存

无名管道

有名管道

消息队列

socket

rpc

com

DCOM

进程间同步

事件

互斥量

信号量

条件变量

文件锁

COM的使用

介绍

概念

CoCreateInstance

临界区

概述

Windows CRITICAL_SECTION

进入临界区时发生什么

从DLL中找函数的地址

查看DLL中的函数

编码

反转链表

单链表排序

你可能也喜欢

热评文章

发表评论

标签云集

`socket`

`rpc`

`com`

`DCOM`

`COM`的使用

`CoCreateInstance`

`Windows` `CRITICAL_SECTION`