linux运维----共享内存

1. 进程间通讯（Inter-Process Communication, IPC）

进程间通讯是指在差别进程之间传送数据或信号的一些方法。由于每个进程都拥有独立的内存空间，因此它们之间的通讯需要借助操作系统提供的特定机制。

• 共享内存（Shared Memory）：共享内存允很多个进程访问同一块内存区域，是效率最高的一种IPC方式。在共享内存中，数据不需要在客户和服务进程间复制，它们可以直接读写同一块内存。但是，这也带来了同步问题，因为多个进程可能同时访问和修改共享内存。
  
  
  
  

2. 系统编程（System Programming）

系统编程涉及直接与操作系统交互，以实现任务管理和资源分配。

• POSIX API：POSIX（Portable Operating System Interface）是一组标准API，用于UNIX和类UNIX操作系统。以下是一些关键的POSIX API和它们的用途：
  
  
  
  • shm_open：创建或打开一个共享内存对象，并返回一个文件形貌符，雷同于打开文件的open系统调用。
    
  • ftruncate：调整共享内存对象的大小，确保它至少与指定的大小一样大。
    
  • mmap：将文件或共享内存映射到进程的地址空间，使得进程可以像访问平常内存一样访问这些资源。
    
  • munmap：排除之前通过mmap映射的内存区域的映射。
    
  • shm_unlink：删除共享内存对象。这雷同于unlink系统调用，用于删除文件。
    
    
    
  
  

3. 同步（Synchronization）

在多进程或多线程环境中，同步机制用于控制对共享资源的访问，以避免竞态条件。

• 信号量（Semaphore）：信号量是一个整数变量，可以用来控制对共享资源的访问。它通常有两个原子操作：P（等待）和V（信号）。在POSIX系统中，信号量可以通过以下API操作：
  
  
  
  • sem_open：创建或打开一个信号量。
    
  • sem_wait：等待信号量（即执行P操作），如果信号量的值大于0，则减1并继续；如果为0，则壅闭直到信号量变为正值。
    
  • sem_post：增加信号量的值（即执行V操作），唤醒等待该信号量的一个进程。
    
  • sem_close：关闭信号量。
    
  • sem_unlink：删除信号量。
    
  
  

4. 文件操作

文件操作是编程中常见的任务，包括打开、读取、写入和关闭文件。

• 文件I/O：在C语言中，文件操作通常使用标准库函数完成：
  
  
  
  • fopen：打开文件。
    
  • fread：从文件读取数据。
    
  • fwrite：向文件写入数据。
    
  • fclose：关闭文件。
    
  
  

5. 错误处理

在系统编程中，错误处理是必不可少的，因为很多操作都可能失败。

• 步伐中使用perror来打印出与当前进程相关的最后一个错误信息。exit用于在发生错误时终止步伐。
  

6. 进程控制

进程控制包括创建新进程、终止进程和利用进程状态。

• fork：创建一个新的进程。fork调用一次，返回两次：在父进程中返回子进程的PID，在子进程中返回0。
  

7. 内存操作

内存操作函数用于设置或读取内存内容。

• memset：设置内存区域的值。常用于初始化内存。
  

8. 类型定义与结构体

C语言提供了类型定义和结构体，用于创建复杂的数据类型。

• typedef：用于为已存在的数据类型创建新的名称。
  
• 结构体（struct）：用于组合多个差别的数据类型，创建新的复合类型。
  

9. 地址空间管理

地址空间管理涉及到怎样将物理内存映射到进程的假造地址空间。

• 内存映射（Memory Mapping）：通过mmap，文件或设备的内容可以映射到进程的地址空间，如许就可以通过读写内存地址来访问文件内容，而不需要使用传统的文件I/O操作。
  
  
  
  

共享内存怎样初始化？

共享内存的初始化通常涉及以下几个步骤：

• 创建共享内存对象：使用系统调用如shmget（在POSIX系统上）或CreateFileMapping（在Windows上）来创建共享内存区域。
  
• 映射共享内存：使用shmat（POSIX）或MapViewOfFile（Windows）将共享内存区域映射到进程的地址空间。
  
• 初始化共享数据：在映射之后，通常会初始化共享内存中的数据结构，以便其他进程能够精确地解释和使用这些数据。
  以下是一个在POSIX兼容系统上初始化共享内存的示例：
  

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <sys/mman.h>
4. #include <sys/stat.h>
5. #include <fcntl.h>
6. #include <unistd.h>
7. #include <string.h>
8. #define SHM_NAME "/my_shm"
9. #define SHM_SIZE 4096  // 假设共享内存大小为4KB
10. int main() {
11.     // 1. 创建共享内存对象
12.     int shm_fd = shm_open(SHM_NAME, O_CREAT | O_RDWR, 0666);
13.     if (shm_fd == -1) {
14.         perror("shm_open");
15.         exit(EXIT_FAILURE);
16.     }
17.     // 2. 调整共享内存大小
18.     if (ftruncate(shm_fd, SHM_SIZE) == -1) {
19.         perror("ftruncate");
20.         exit(EXIT_FAILURE);
21.     }
22.     // 3. 映射共享内存到进程地址空间
23.     void *shm_ptr = mmap(NULL, SHM_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0);
24.     if (shm_ptr == MAP_FAILED) {
25.         perror("mmap");
26.         exit(EXIT_FAILURE);
27.     }
28.     // 4. 初始化共享内存中的数据
29.     memset(shm_ptr, 0, SHM_SIZE);  // 清零共享内存区域
30.     // 示例：创建一个简单的共享结构体
31.     typedef struct {
32.         int value;
33.         char buffer[1024];
34.     } SharedData;
35.     SharedData *shared_data = (SharedData *)shm_ptr;
36.     shared_data->value = 42;  // 初始化值
37.     strncpy(shared_data->buffer, "Hello, Shared Memory!", sizeof(shared_data->buffer));
38.     // 使用共享内存...
39.     // 5. 解除映射
40.     if (munmap(shm_ptr, SHM_SIZE) == -1) {
41.         perror("munmap");
42.         exit(EXIT_FAILURE);
43.     }
44.     // 6. 关闭共享内存对象
45.     if (close(shm_fd) == -1) {
46.         perror("close");
47.         exit(EXIT_FAILURE);
48.     }
49.     // 7. 删除共享内存对象（如果不再需要）
50.     if (shm_unlink(SHM_NAME) == -1) {
51.         perror("shm_unlink");
52.         exit(EXIT_FAILURE);
53.     }
54.     return 0;
55. }

复制代码

在这个示例中，我们起首使用shm_open创建一个新的共享内存对象，然后使用ftruncate调整它的大小，接着使用mmap将其映射到进程的地址空间。映射后，我们使用memset来清零整个共享内存区域，并初始化一个SharedData结构体。使用完毕后，我们使用munmap排除映射，使用close关闭共享内存文件形貌符，并最终使用shm_unlink删除共享内存对象。
请记住，在多进程环境中，通常需要一个进程负责创建和初始化共享内存，而其他进程则直接映射并使用它。删除共享内存对象应该是在所有进程都完成使用后举行的。
在编程实现两个没有亲缘关系的进程之间通过共享内存传递文件内容时，我们需要使用操作系统提供的API来创建和管理共享内存，以及同步原语来保证同步访问。以下是一个简化的示例，展示了怎样使用 POSIX 共享内存和信号量在类Unix系统中完成这个过程。

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <string.h>
4. #include <sys/mman.h>
5. #include <sys/stat.h>
6. #include <fcntl.h>
7. #include <unistd.h>
8. #include <semaphore.h>
9. #include <sys/types.h>
10. #define SHM_NAME "/my_shm"
11. #define SEM_NAME "/my_sem"
12. // 假设共享内存大小为1MB
13. #define SHM_SIZE 1024 * 1024
14. // 文件传输结构体
15. typedef struct {
16.     size_t file_size; // 文件总大小
17.     char data[SHM_SIZE - sizeof(size_t)]; // 剩余空间用于存储数据
18. } FileTransfer;
19. void write_to_shm(const char* filename, sem_t* sem) {
20.     int shm_fd = shm_open(SHM_NAME, O_CREAT | O_RDWR, 0666);
21.     if (shm_fd == -1) {
22.         perror("shm_open");
23.         exit(EXIT_FAILURE);
24.     }
25.     // 调整共享内存大小
26.     if (ftruncate(shm_fd, SHM_SIZE) == -1) {
27.         perror("ftruncate");
28.         exit(EXIT_FAILURE);
29.     }
30.     // 映射共享内存
31.     FileTransfer* transfer = mmap(NULL, SHM_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0);
32.     if (transfer == MAP_FAILED) {
33.         perror("mmap");
34.         exit(EXIT_FAILURE);
35.     }
36.     // 打开文件
37.     FILE* file = fopen(filename, "rb");
38.     if (file == NULL) {
39.         perror("fopen");
40.         exit(EXIT_FAILURE);
41.     }
42.     // 获取文件大小
43.     fseek(file, 0, SEEK_END);
44.     transfer->file_size = ftell(file);
45.     rewind(file);
46.     size_t bytes_written = 0;
47.     size_t bytes_to_write;
48.     char buffer[SHM_SIZE - sizeof(size_t)];
49.     // 循环写入文件内容到共享内存
50.     while (bytes_written < transfer->file_size) {
51.         bytes_to_write = sizeof(buffer);
52.         if (bytes_written + bytes_to_write > transfer->file_size) {
53.             bytes_to_write = transfer->file_size - bytes_written;
54.         }
55.         fread(buffer, 1, bytes_to_write, file);
56.         memcpy(transfer->data, buffer, bytes_to_write);
57.         // 同步访问
58.         sem_post(sem);
59.         // 等待读进程读取完成
60.         sem_wait(sem);
61.         bytes_written += bytes_to_write;
62.     }
63.     // 关闭文件和共享内存
64.     fclose(file);
65.     munmap(transfer, SHM_SIZE);
66.     close(shm_fd);
67. }
68. void read_from_shm(sem_t* sem) {
69.     int shm_fd = shm_open(SHM_NAME, O_RDONLY, 0666);
70.     if (shm_fd == -1) {
71.         perror("shm_open");
72.         exit(EXIT_FAILURE);
73.     }
74.     // 映射共享内存
75.     FileTransfer* transfer = mmap(NULL, SHM_SIZE, PROT_READ, MAP_SHARED, shm_fd, 0);
76.     if (transfer == MAP_FAILED) {
77.         perror("mmap");
78.         exit(EXIT_FAILURE);
79.     }
80.     FILE* file = fopen("output_file", "wb");
81.     if (file == NULL) {
82.         perror("fopen");
83.         exit(EXIT_FAILURE);
84.     }
85.     size_t bytes_read = 0;
86.     size_t bytes_to_read;
87.     char buffer[SHM_SIZE - sizeof(size_t)];
88.     // 循环读取共享内存内容到文件
89.     while (bytes_read < transfer->file_size) {
90.         // 等待写进程写入数据
91.         sem_wait(sem);
92.         bytes_to_read = sizeof(buffer);
93.         if (bytes_read + bytes_to_read > transfer->file_size) {
94.             bytes_to_read = transfer->file_size - bytes_read;
95.         }
96.         memcpy(buffer, transfer->data, bytes_to_read);
97.         fwrite(buffer, 1, bytes_to_read, file);
98.         // 通知写进程可以继续写入
99.         sem_post(sem);
100.         bytes_read += bytes_to_read;
101.     }
102.     // 关闭文件和共享内存
103.     fclose(file);
104.     munmap(transfer, SHM_SIZE);
105.     close(shm_fd);
106. }
107. int main() {
108.     sem_t* sem = sem_open(SEM_NAME, O_CREAT, 0666, 0);
109.     if (sem == SEM_FAILED) {
110.         perror("sem_open");
111.         exit(EXIT_FAILURE);
112.     }
113.     pid_t pid = fork();
114.     if (pid == -1) {
115.         perror("fork");
116.         exit(EXIT_FAILURE);
117.     }
118.    
119.     if (pid > 0) {
120.         // 父进程负责写入共享内存
121.         write_to_shm("input_file", sem);
122.     } else {
123.         // 子进程负责从共享内存读取
124.         read_from_shm(sem);
125.     }
126.     // 清理信号量
127.     sem_close(sem);
128.     sem_unlink(SEM_NAME);
129.     // 清理共享内存
130.     shm_unlink(SHM_NAME);
131.     return 0;
132. }

复制代码

这个步伐做了以下几件变乱：

• 定义了一个共享内存的结构体FileTransfer，此中包罗文件大小和用于存储数据的缓冲区。
  
• write_to_shm函数负责打开文件，读取内容，并将其写入共享内存。它使用一个信号量来同步写入操作。
  
• read_from_shm函数负责从共享内存读取内容，并将其写入一个新文件。它同样使用信号量来同步读取操作。
  
• 在main函数中，创建了一个信号量，并使用fork创建了一个子进程。父进程调用write_to_shm，子进程调用read_from_shm。
  
• 在文件传输完成后，步伐清理了信号量和共享内存。
  请注意，为了简化代码，这里没有处理所有可能的错误情况，现实应用中需要更加结实的错误处理。别的，该示例假设共享内存和信号量的创建和使用是在同一个步伐的两个进程之间举行的，但在现实应用中，可能需要单独的步伐来分别执行写入和读取操作，此时需要确保两个步伐都能访问到雷同的共享内存和信号量。
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。