프로세스 간의 5가지 통신 방법은 무엇입니까?
프로세스 간 5가지 통신 방법: 1. 파이프라인은 느리고 용량이 제한적입니다. 상위 프로세스와 하위 프로세스만 통신할 수 있습니다. 2. 모든 프로세스 간에 통신할 수 있지만 속도가 느린 FIFO. 메시지 무작위 쿼리를 구현할 수 있으며 용량은 시스템에 의해 제한됩니다. 4. 세마포어는 복잡한 메시지를 전송할 수 없으며 동기화에만 사용할 수 있습니다. 5. 공유 메모리 영역은 두 개 이상의 프로세스가 지정된 저장 영역을 공유한다는 것을 의미합니다.
이 튜토리얼의 운영 환경: Windows 7 시스템, Dell G3 컴퓨터.
프로세스 간 다섯 가지 통신 방법:
1. 파이프
일반적으로 이름 없는 파이프라고 불리는 파이프는 UNIX 시스템 IPC의 가장 오래된 형태입니다.
1. 기능:
읽기 및 쓰기 끝이 고정된 반이중(즉, 데이터가 한 방향으로만 흐를 수 있음)입니다.
관계가 있는 프로세스 간(부모-자식 프로세스 또는 형제 프로세스 간) 통신에만 사용할 수 있습니다.
특수 파일로 간주할 수 있으며 일반적인 읽기, 쓰기 및 기타 기능을 사용하여 읽고 쓸 수도 있습니다. 그러나 이는 일반적인 파일이 아니며, 다른 파일 시스템에 속하지 않으며, 메모리에만 존재합니다.
2. 프로토타입:
1 #include <unistd.h> 2 int pipe(int fd[2]); // 返回值：若成功返回0，失败返回-1</unistd.h>
파이프라인이 설정되면 두 개의 파일 설명자(fd[0]가 읽기용으로 열림, fd[1 ])가 생성됩니다. > 글쓰기를 위해 열려있습니다. 아래와 같이 fd[0]为读而打开，fd[1]为写而打开。如下图：
要关闭管道只需将这两个文件描述符关闭即可。
3、例子
单个进程中的管道几乎没有任何用处。所以，通常调用 pipe 的进程接着调用 fork，这样就创建了父进程与子进程之间的 IPC 通道。如下图所示：
若要数据流从父进程流向子进程，则关闭父进程的读端（fd[0]）与子进程的写端（fd[1]）；反之，则可以使数据流从子进程流向父进程。
1 #include<stdio.h>
2 #include<unistd.h>
3
4 int main()
5 {
6 int fd[2]; // 两个文件描述符
7 pid_t pid;
8 char buff[20];
9
10 if(pipe(fd) 0) // 父进程
16 {
17 close(fd[0]); // 关闭读端
18 write(fd[1], "hello world\n", 12);
19 }
20 else
21 {
22 close(fd[1]); // 关闭写端
23 read(fd[0], buff, 20);
24 printf("%s", buff);
25 }
26
27 return 0;
28 }</unistd.h></stdio.h>二、FIFO
FIFO，也称为命名管道，它是一种文件类型。
1、特点
FIFO可以在无关的进程之间交换数据，与无名管道不同。
FIFO有路径名与之相关联，它以一种特殊设备文件形式存在于文件系统中。
2、原型
1 #include <sys> 2 // 返回值：成功返回0，出错返回-1 3 int mkfifo(const char *pathname, mode_t mode);</sys>
其中的 mode 参数与open函数中的 mode 相同。一旦创建了一个 FIFO，就可以用一般的文件I/O函数操作它。
当 open 一个FIFO时，是否设置非阻塞标志（O_NONBLOCK）的区别：
若没有指定
O_NONBLOCK（默认），只读 open 要阻塞到某个其他进程为写而打开此 FIFO。类似的，只写 open 要阻塞到某个其他进程为读而打开它。若指定了
O_NONBLOCK，则只读 open 立即返回。而只写 open 将出错返回 -1 如果没有进程已经为读而打开该 FIFO，其errno置ENXIO。
3、例子
FIFO的通信方式类似于在进程中使用文件来传输数据，只不过FIFO类型文件同时具有管道的特性。在数据读出时，FIFO管道中同时清除数据，并且“先进先出”。下面的例子演示了使用 FIFO 进行 IPC 的过程：
write_fifo.c
1 #include<stdio.h>
2 #include<stdlib.h> // exit
3 #include<fcntl.h> // O_WRONLY
4 #include<sys>
5 #include<time.h> // time
6
7 int main()
8 {
9 int fd;
10 int n, i;
11 char buf[1024];
12 time_t tp;
13
14 printf("I am %d process.\n", getpid()); // 说明进程ID
15
16 if((fd = open("fifo1", O_WRONLY)) <p>read_fifo.c</p>
<pre class="brush:php;toolbar:false"> 1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<errno.h>
4 #include<fcntl.h>
5 #include<sys>
6
7 int main()
8 {
9 int fd;
10 int len;
11 char buf[1024];
12
13 if(mkfifo("fifo1", 0666) 0) // 读取FIFO管道
23 printf("Read message: %s", buf);
24
25 close(fd); // 关闭FIFO文件
26 return 0;
27 }</sys></fcntl.h></errno.h></stdlib.h></stdio.h>在两个终端里用 gcc 分别编译运行上面两个文件，可以看到输出结果如下：
1 [cheesezh@localhost]$ ./write_fifo 2 I am 5954 process. 3 Send message: Process 5954's time is Mon Apr 20 12:37:28 2015 4 Send message: Process 5954's time is Mon Apr 20 12:37:29 2015 5 Send message: Process 5954's time is Mon Apr 20 12:37:30 2015 6 Send message: Process 5954's time is Mon Apr 20 12:37:31 2015 7 Send message: Process 5954's time is Mon Apr 20 12:37:32 2015 8 Send message: Process 5954's time is Mon Apr 20 12:37:33 2015 9 Send message: Process 5954's time is Mon Apr 20 12:37:34 2015 10 Send message: Process 5954's time is Mon Apr 20 12:37:35 2015 11 Send message: Process 5954's time is Mon Apr 20 12:37:36 2015 12 Send message: Process 5954's time is Mon Apr 20 12:37:37 2015
1 [cheesezh@localhost]$ ./read_fifo 2 Read message: Process 5954's time is Mon Apr 20 12:37:28 2015 3 Read message: Process 5954's time is Mon Apr 20 12:37:29 2015 4 Read message: Process 5954's time is Mon Apr 20 12:37:30 2015 5 Read message: Process 5954's time is Mon Apr 20 12:37:31 2015 6 Read message: Process 5954's time is Mon Apr 20 12:37:32 2015 7 Read message: Process 5954's time is Mon Apr 20 12:37:33 2015 8 Read message: Process 5954's time is Mon Apr 20 12:37:34 2015 9 Read message: Process 5954's time is Mon Apr 20 12:37:35 2015 10 Read message: Process 5954's time is Mon Apr 20 12:37:36 2015 11 Read message: Process 5954's time is Mon Apr 20 12:37:37 2015
上述例子可以扩展成 客户进程—服务器进程 通信的实例，write_fifo的作用类似于客户端，可以打开多个客户端向一个服务器发送请求信息，read_fifo
파이프를 닫으려면, 그냥 이 두 파일 설명자를 닫으세요.
3.Example
단일 공정의 파이프는 거의 쓸모가 없습니다. 따라서 일반적으로 파이프를 호출하는 프로세스는 포크를 호출하여 상위 프로세스와 하위 프로세스 사이에 IPC 채널을 생성합니다. 아래 그림과 같이:
데이터 흐름이 상위 프로세스에서 하위 프로세스로 흐르는 경우 상위 프로세스의 읽기 끝(fd[0])과 하위 프로세스의 쓰기 끝( fd[1]); 반대로, 데이터 흐름은 하위 프로세스에서 상위 프로세스로 이루어질 수 있습니다. <ol>
<div class="code" style="position:relative; padding:0px; margin:0px;"><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false">1 #include <sys>
2 // 创建或打开消息队列：成功返回队列ID，失败返回-1
3 int msgget(key_t key, int flag);
4 // 添加消息：成功返回0，失败返回-1
5 int msgsnd(int msqid, const void *ptr, size_t size, int flag);
6 // 读取消息：成功返回消息数据的长度，失败返回-1
7 int msgrcv(int msqid, void *ptr, size_t size, long type,int flag);
8 // 控制消息队列：成功返回0，失败返回-1
9 int msgctl(int msqid, int cmd, struct msqid_ds *buf);</sys></pre><div class="contentsignin">로그인 후 복사</div></div><div class="contentsignin">로그인 후 복사</div></div>
<h2 id="two.FIFO"></h2>
<li>two、FIFO<p></p>
</li>FIFO는 명명된 파이프라고도 알려진 파일 형식입니다. <li>
<h3 id="특징">1. 특징 </h3>
<p></p>🎜🎜FIFO는 이름 없는 파이프와 달리 관련 없는 프로세스 간에 데이터를 교환할 수 있습니다. 🎜🎜🎜🎜FIFO에는 연결된 경로 이름이 있으며 파일 시스템에 특수 장치 파일로 존재합니다. 🎜🎜</li>
</ol>
<h3 id="2.Prototype">2. 프로토타입 🎜<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false"> 1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <sys>
4
5 // 用于创建一个唯一的key
6 #define MSG_FILE "/etc/passwd"
7
8 // 消息结构
9 struct msg_form {
10 long mtype;
11 char mtext[256];
12 };
13
14 int main()
15 {
16 int msqid;
17 key_t key;
18 struct msg_form msg;
19
20 // 获取key值
21 if((key = ftok(MSG_FILE,'z')) 🎜 모드 매개변수는 <code>open</code> 함수의 모드와 동일합니다. FIFO가 생성되면 일반 파일 I/O 기능을 사용하여 조작할 수 있습니다. 🎜🎜FIFO를 열 때 비차단 플래그(<code>O_NONBLOCK</code>) 설정 여부의 차이: 🎜<ul>🎜🎜<code>O_NONBLOCK</code>이 지정되지 않은 경우(기본값) , 읽기 전용 열기 다른 프로세스가 쓰기를 위해 이 FIFO를 열 때까지 차단합니다. 마찬가지로 쓰기 전용 열기는 다른 프로세스가 읽기 위해 열 때까지 차단됩니다. 🎜🎜🎜🎜<code>O_NONBLOCK</code>을 지정하면 읽기 전용 열기가 즉시 반환됩니다. 쓰기 전용 열기는 오류 시 -1을 반환합니다. 읽기 위해 FIFO를 연 프로세스가 없으면 해당 errno는 ENXIO로 설정됩니다. 🎜🎜🎜<h3 id="3.Example-1">3. 예시 🎜🎜FIFO 형식의 파일도 파이프의 특성을 갖는다는 점을 제외하면 FIFO의 통신 방법은 파일을 사용하여 프로세스에서 데이터를 전송하는 것과 유사합니다. 데이터를 읽으면 동시에 FIFO 파이프라인에서 데이터가 지워지고 "선입선출"됩니다. 다음 예는 IPC에 FIFO를 사용하는 과정을 보여줍니다. 🎜🎜write_fifo.c🎜<pre class="brush:php;toolbar:false"> 1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <sys>
4
5 // 用于创建一个唯一的key
6 #define MSG_FILE "/etc/passwd"
7
8 // 消息结构
9 struct msg_form {
10 long mtype;
11 char mtext[256];
12 };
13
14 int main()
15 {
16 int msqid;
17 key_t key;
18 struct msg_form msg;
19
20 // 获取key值
21 if ((key = ftok(MSG_FILE, 'z')) 🎜read_fifo.c🎜<pre class="brush:php;toolbar:false">1 #include <sys>
2 // 创建或获取一个信号量组：若成功返回信号量集ID，失败返回-1
3 int semget(key_t key, int num_sems, int sem_flags);
4 // 对信号量组进行操作，改变信号量的值：成功返回0，失败返回-1
5 int semop(int semid, struct sembuf semoparray[], size_t numops);
6 // 控制信号量的相关信息
7 int semctl(int semid, int sem_num, int cmd, ...);</sys></pre><div class="contentsignin">로그인 후 복사</div></div>🎜gcc를 사용하여 두 터미널에서 위 두 파일을 컴파일하고 실행하면 다음과 같은 출력을 볼 수 있습니다. 🎜위의 예는 클라이언트 프로세스-서버 프로세스 통신의 예로 확장될 수 있습니다. <code>read_fifo는 클라이언트처럼 여러 클라이언트를 열어 요청 정보를 보낼 수 있습니다. code > 서버와 유사하게 FIFO의 읽기 종료를 적시에 모니터링합니다. 데이터가 있으면 읽어서 처리합니다. 그러나 중요한 문제는 각 클라이언트가 제공하는 FIFO 인터페이스를 알아야 한다는 것입니다. 아래 그림은 이 배열을 보여줍니다. 🎜🎜🎜🎜🎜🎜 3. 메시지 큐 🎜🎜🎜 메시지 큐는 커널에 저장된 메시지의 링크된 테이블입니다. 메시지 큐는 식별자(큐 ID)로 식별됩니다. 🎜🎜1. 특징🎜🎜🎜🎜메시지 대기열은 기록 지향적이며, 그 안에 있는 메시지는 특정 형식과 특정 우선 순위를 갖습니다. 🎜🎜🎜🎜메시지 대기열은 전송 및 수신 프로세스와 독립적입니다. 프로세스가 종료되면 메시지 큐와 해당 내용은 삭제되지 않습니다. 🎜消息队列可以实现消息的随机查询,消息不一定要以先进先出的次序读取,也可以按消息的类型读取。
2、原型
1 #include <sys> 2 // 创建或打开消息队列：成功返回队列ID，失败返回-1 3 int msgget(key_t key, int flag); 4 // 添加消息：成功返回0，失败返回-1 5 int msgsnd(int msqid, const void *ptr, size_t size, int flag); 6 // 读取消息：成功返回消息数据的长度，失败返回-1 7 int msgrcv(int msqid, void *ptr, size_t size, long type,int flag); 8 // 控制消息队列：成功返回0，失败返回-1 9 int msgctl(int msqid, int cmd, struct msqid_ds *buf);</sys>
在以下两种情况下，msgget将创建一个新的消息队列：
- 如果没有与键值key相对应的消息队列，并且flag中包含了
IPC_CREAT标志位。 - key参数为
IPC_PRIVATE。
函数msgrcv在读取消息队列时，type参数有下面几种情况：
-
type == 0，返回队列中的第一个消息； -
type > 0，返回队列中消息类型为 type 的第一个消息； type ，返回队列中消息类型值小于或等于 type 绝对值的消息，如果有多个，则取类型值最小的消息。
可以看出，type值非 0 时用于以非先进先出次序读消息。也可以把 type 看做优先级的权值。（其他的参数解释，请自行Google之）
3、例子
下面写了一个简单的使用消息队列进行IPC的例子，服务端程序一直在等待特定类型的消息，当收到该类型的消息以后，发送另一种特定类型的消息作为反馈，客户端读取该反馈并打印出来。
msg_server.c
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <sys>
4
5 // 用于创建一个唯一的key
6 #define MSG_FILE "/etc/passwd"
7
8 // 消息结构
9 struct msg_form {
10 long mtype;
11 char mtext[256];
12 };
13
14 int main()
15 {
16 int msqid;
17 key_t key;
18 struct msg_form msg;
19
20 // 获取key值
21 if((key = ftok(MSG_FILE,'z')) <p>msg_client.c</p>
<pre class="brush:php;toolbar:false"> 1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <sys>
4
5 // 用于创建一个唯一的key
6 #define MSG_FILE "/etc/passwd"
7
8 // 消息结构
9 struct msg_form {
10 long mtype;
11 char mtext[256];
12 };
13
14 int main()
15 {
16 int msqid;
17 key_t key;
18 struct msg_form msg;
19
20 // 获取key值
21 if ((key = ftok(MSG_FILE, 'z')) <h2 id="strong-四-信号量-strong"><strong>四、信号量</strong></h2>
<p>信号量（semaphore）与已经介绍过的 IPC 结构不同，它是一个计数器。信号量用于实现进程间的互斥与同步，而不是用于存储进程间通信数据。</p>
<h3 id="特点">1、特点</h3>
<ol>
<li><p>信号量用于进程间同步，若要在进程间传递数据需要结合共享内存。</p></li>
<li><p>信号量基于操作系统的 PV 操作，程序对信号量的操作都是原子操作。</p></li>
<li><p>每次对信号量的 PV 操作不仅限于对信号量值加 1 或减 1，而且可以加减任意正整数。</p></li>
<li><p>支持信号量组。</p></li>
</ol>
<h3 id="原型">2、原型</h3>
<p>最简单的信号量是只能取 0 和 1 的变量，这也是信号量最常见的一种形式，叫做二值信号量（Binary Semaphore）。而可以取多个正整数的信号量被称为通用信号量。</p>
<p>Linux 下的信号量函数都是在通用的信号量数组上进行操作，而不是在一个单一的二值信号量上进行操作。</p>
<pre class="brush:php;toolbar:false">1 #include <sys>
2 // 创建或获取一个信号量组：若成功返回信号量集ID，失败返回-1
3 int semget(key_t key, int num_sems, int sem_flags);
4 // 对信号量组进行操作，改变信号量的值：成功返回0，失败返回-1
5 int semop(int semid, struct sembuf semoparray[], size_t numops);
6 // 控制信号量的相关信息
7 int semctl(int semid, int sem_num, int cmd, ...);</sys>当semget创建新的信号量集合时，必须指定集合中信号量的个数（即num_sems），通常为1； 如果是引用一个现有的集合，则将num_sems指定为 0 。
在semop函数中，sembuf结构的定义如下：
1 struct sembuf
2 {
3 short sem_num; // 信号量组中对应的序号，0～sem_nums-1
4 short sem_op; // 信号量值在一次操作中的改变量
5 short sem_flg; // IPC_NOWAIT, SEM_UNDO
6 }其中 sem_op 是一次操作中的信号量的改变量：
若
sem_op > 0，表示进程释放相应的资源数，将 sem_op 的值加到信号量的值上。如果有进程正在休眠等待此信号量，则换行它们。-
若
sem_op ，请求 sem_op 的绝对值的资源。- 如果相应的资源数可以满足请求，则将该信号量的值减去sem_op的绝对值，函数成功返回。
- 当相应的资源数不能满足请求时，这个操作与
sem_flg有关。- sem_flg 指定
IPC_NOWAIT，则semop函数出错返回EAGAIN。 - sem_flg 没有指定
IPC_NOWAIT，则将该信号量的semncnt值加1，然后进程挂起直到下述情况发生：- 当相应的资源数可以满足请求，此信号量的semncnt值减1，该信号量的值减去sem_op的绝对值。成功返回；
- 此信号量被删除，函数smeop出错返回EIDRM；
- 进程捕捉到信号，并从信号处理函数返回，此情况下将此信号量的semncnt值减1，函数semop出错返回EINTR
- sem_flg 指定
-
若
sem_op == 0，进程阻塞直到信号量的相应值为0：- 当信号量已经为0，函数立即返回。
- 如果信号量的值不为0，则依据
sem_flg决定函数动作：- sem_flg指定
IPC_NOWAIT，则出错返回EAGAIN。 - sem_flg没有指定
IPC_NOWAIT，则将该信号量的semncnt值加1，然后进程挂起直到下述情况发生：- 信号量值为0，将信号量的semzcnt的值减1，函数semop成功返回；
- 此信号量被删除，函数smeop出错返回EIDRM；
- 进程捕捉到信号，并从信号处理函数返回，在此情况将此信号量的semncnt值减1，函数semop出错返回EINTR
- sem_flg指定
在semctl函数中的命令有多种，这里就说两个常用的：
-
SETVAL：用于初始化信号量为一个已知的值。所需要的值作为联合semun的val成员来传递。在信号量第一次使用之前需要设置信号量。 -
IPC_RMID：删除一个信号量集合。如果不删除信号量，它将继续在系统中存在，即使程序已经退出，它可能在你下次运行此程序时引发问题，而且信号量是一种有限的资源。
3、例子
1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<sys>
4
5 // 联合体，用于semctl初始化
6 union semun
7 {
8 int val; /*for SETVAL*/
9 struct semid_ds *buf;
10 unsigned short *array;
11 };
12
13 // 初始化信号量
14 int init_sem(int sem_id, int value)
15 {
16 union semun tmp;
17 tmp.val = value;
18 if(semctl(sem_id, 0, SETVAL, tmp) == -1)
19 {
20 perror("Init Semaphore Error");
21 return -1;
22 }
23 return 0;
24 }
25
26 // P操作:
27 // 若信号量值为1，获取资源并将信号量值-1
28 // 若信号量值为0，进程挂起等待
29 int sem_p(int sem_id)
30 {
31 struct sembuf sbuf;
32 sbuf.sem_num = 0; /*序号*/
33 sbuf.sem_op = -1; /*P操作*/
34 sbuf.sem_flg = SEM_UNDO;
35
36 if(semop(sem_id, &sbuf, 1) == -1)
37 {
38 perror("P operation Error");
39 return -1;
40 }
41 return 0;
42 }
43
44 // V操作：
45 // 释放资源并将信号量值+1
46 // 如果有进程正在挂起等待，则唤醒它们
47 int sem_v(int sem_id)
48 {
49 struct sembuf sbuf;
50 sbuf.sem_num = 0; /*序号*/
51 sbuf.sem_op = 1; /*V操作*/
52 sbuf.sem_flg = SEM_UNDO;
53
54 if(semop(sem_id, &sbuf, 1) == -1)
55 {
56 perror("V operation Error");
57 return -1;
58 }
59 return 0;
60 }
61
62 // 删除信号量集
63 int del_sem(int sem_id)
64 {
65 union semun tmp;
66 if(semctl(sem_id, 0, IPC_RMID, tmp) == -1)
67 {
68 perror("Delete Semaphore Error");
69 return -1;
70 }
71 return 0;
72 }
73
74
75 int main()
76 {
77 int sem_id; // 信号量集ID
78 key_t key;
79 pid_t pid;
80
81 // 获取key值
82 if((key = ftok(".", 'z')) <p>上面的例子如果不加信号量，则父进程会先执行完毕。这里加了信号量让父进程等待子进程执行完以后再执行。</p>
<h2 id="strong-五-共享内存-strong"><strong>五、共享内存</strong></h2>
<p>共享内存（Shared Memory），指两个或多个进程共享一个给定的存储区。</p>
<h3 id="特点">1、特点</h3>
<ol>
<li><p>共享内存是最快的一种 IPC，因为进程是直接对内存进行存取。</p></li>
<li><p>因为多个进程可以同时操作，所以需要进行同步。</p></li>
<li><p>信号量+共享内存通常结合在一起使用，信号量用来同步对共享内存的访问。</p></li>
</ol>
<h3 id="原型">2、原型</h3>
<pre class="brush:php;toolbar:false">1 #include <sys>
2 // 创建或获取一个共享内存：成功返回共享内存ID，失败返回-1
3 int shmget(key_t key, size_t size, int flag);
4 // 连接共享内存到当前进程的地址空间：成功返回指向共享内存的指针，失败返回-1
5 void *shmat(int shm_id, const void *addr, int flag);
6 // 断开与共享内存的连接：成功返回0，失败返回-1
7 int shmdt(void *addr);
8 // 控制共享内存的相关信息：成功返回0，失败返回-1
9 int shmctl(int shm_id, int cmd, struct shmid_ds *buf);</sys>当用shmget函数创建一段共享内存时，必须指定其 size；而如果引用一个已存在的共享内存，则将 size 指定为0 。
当一段共享内存被创建以后，它并不能被任何进程访问。必须使用shmat函数连接该共享内存到当前进程的地址空间，连接成功后把共享内存区对象映射到调用进程的地址空间，随后可像本地空间一样访问。
shmdt函数是用来断开shmat建立的连接的。注意，这并不是从系统中删除该共享内存，只是当前进程不能再访问该共享内存而已。
shmctl函数可以对共享内存执行多种操作，根据参数 cmd 执行相应的操作。常用的是IPC_RMID（从系统中删除该共享内存）。
3、例子
下面这个例子，使用了【共享内存+信号量+消息队列】的组合来实现服务器进程与客户进程间的通信。
- 共享内存用来传递数据；
- 信号量用来同步；
- 消息队列用来 在客户端修改了共享内存后 通知服务器读取。
server.c
1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<sys> // shared memory
4 #include<sys> // semaphore
5 #include<sys> // message queue
6 #include<string.h> // memcpy
7
8 // 消息队列结构
9 struct msg_form {
10 long mtype;
11 char mtext;
12 };
13
14 // 联合体，用于semctl初始化
15 union semun
16 {
17 int val; /*for SETVAL*/
18 struct semid_ds *buf;
19 unsigned short *array;
20 };
21
22 // 初始化信号量
23 int init_sem(int sem_id, int value)
24 {
25 union semun tmp;
26 tmp.val = value;
27 if(semctl(sem_id, 0, SETVAL, tmp) == -1)
28 {
29 perror("Init Semaphore Error");
30 return -1;
31 }
32 return 0;
33 }
34
35 // P操作:
36 // 若信号量值为1，获取资源并将信号量值-1
37 // 若信号量值为0，进程挂起等待
38 int sem_p(int sem_id)
39 {
40 struct sembuf sbuf;
41 sbuf.sem_num = 0; /*序号*/
42 sbuf.sem_op = -1; /*P操作*/
43 sbuf.sem_flg = SEM_UNDO;
44
45 if(semop(sem_id, &sbuf, 1) == -1)
46 {
47 perror("P operation Error");
48 return -1;
49 }
50 return 0;
51 }
52
53 // V操作：
54 // 释放资源并将信号量值+1
55 // 如果有进程正在挂起等待，则唤醒它们
56 int sem_v(int sem_id)
57 {
58 struct sembuf sbuf;
59 sbuf.sem_num = 0; /*序号*/
60 sbuf.sem_op = 1; /*V操作*/
61 sbuf.sem_flg = SEM_UNDO;
62
63 if(semop(sem_id, &sbuf, 1) == -1)
64 {
65 perror("V operation Error");
66 return -1;
67 }
68 return 0;
69 }
70
71 // 删除信号量集
72 int del_sem(int sem_id)
73 {
74 union semun tmp;
75 if(semctl(sem_id, 0, IPC_RMID, tmp) == -1)
76 {
77 perror("Delete Semaphore Error");
78 return -1;
79 }
80 return 0;
81 }
82
83 // 创建一个信号量集
84 int creat_sem(key_t key)
85 {
86 int sem_id;
87 if((sem_id = semget(key, 1, IPC_CREAT|0666)) == -1)
88 {
89 perror("semget error");
90 exit(-1);
91 }
92 init_sem(sem_id, 1); /*初值设为1资源未占用*/
93 return sem_id;
94 }
95
96
97 int main()
98 {
99 key_t key;
100 int shmid, semid, msqid;
101 char *shm;
102 char data[] = "this is server";
103 struct shmid_ds buf1; /*用于删除共享内存*/
104 struct msqid_ds buf2; /*用于删除消息队列*/
105 struct msg_form msg; /*消息队列用于通知对方更新了共享内存*/
106
107 // 获取key值
108 if((key = ftok(".", 'z')) <p>client.c</p>
<pre class="brush:php;toolbar:false"> 1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<sys> // shared memory
4 #include<sys> // semaphore
5 #include<sys> // message queue
6 #include<string.h> // memcpy
7
8 // 消息队列结构
9 struct msg_form {
10 long mtype;
11 char mtext;
12 };
13
14 // 联合体，用于semctl初始化
15 union semun
16 {
17 int val; /*for SETVAL*/
18 struct semid_ds *buf;
19 unsigned short *array;
20 };
21
22 // P操作:
23 // 若信号量值为1，获取资源并将信号量值-1
24 // 若信号量值为0，进程挂起等待
25 int sem_p(int sem_id)
26 {
27 struct sembuf sbuf;
28 sbuf.sem_num = 0; /*序号*/
29 sbuf.sem_op = -1; /*P操作*/
30 sbuf.sem_flg = SEM_UNDO;
31
32 if(semop(sem_id, &sbuf, 1) == -1)
33 {
34 perror("P operation Error");
35 return -1;
36 }
37 return 0;
38 }
39
40 // V操作：
41 // 释放资源并将信号量值+1
42 // 如果有进程正在挂起等待，则唤醒它们
43 int sem_v(int sem_id)
44 {
45 struct sembuf sbuf;
46 sbuf.sem_num = 0; /*序号*/
47 sbuf.sem_op = 1; /*V操作*/
48 sbuf.sem_flg = SEM_UNDO;
49
50 if(semop(sem_id, &sbuf, 1) == -1)
51 {
52 perror("V operation Error");
53 return -1;
54 }
55 return 0;
56 }
57
58
59 int main()
60 {
61 key_t key;
62 int shmid, semid, msqid;
63 char *shm;
64 struct msg_form msg;
65 int flag = 1; /*while循环条件*/
66
67 // 获取key值
68 if((key = ftok(".", 'z')) <p>注意：当<code>scanf()</code>输入字符或字符串时，缓冲区中遗留下了<code>\n</code>，所以每次输入操作后都需要清空标准输入的缓冲区。但是由于 gcc 编译器不支持<code>fflush(stdin)</code>（它只是标准C的扩展），所以我们使用了替代方案：</p>
<pre class="brush:php;toolbar:false">1 while((c=getchar())!='\n' && c!=EOF);五种通讯方式总结
1.管道：速度慢，容量有限，只有父子进程能通讯
2.FIFO：任何进程间都能通讯，但速度慢
3.消息队列：容量受到系统限制，且要注意第一次读的时候，要考虑上一次没有读完数据的问题
4.信号量：不能传递复杂消息，只能用来同步
5.共享内存区：能够很容易控制容量，速度快，但要保持同步，比如一个进程在写的时候，另一个进程要注意读写的问题，相当于线程中的线程安全，当然，共享内存区同样可以用作线程间通讯，不过没这个必要，线程间本来就已经共享了同一进程内的一块内存
相关免费学习推荐：php编程（视频）
위 내용은 프로세스 간의 5가지 통신 방법은 무엇입니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!
핫 AI 도구
Undresser.AI Undress
사실적인 누드 사진을 만들기 위한 AI 기반 앱
AI Clothes Remover
사진에서 옷을 제거하는 온라인 AI 도구입니다.
Undress AI Tool
무료로 이미지를 벗다
Clothoff.io
AI 옷 제거제
AI Hentai Generator
AI Hentai를 무료로 생성하십시오.
인기 기사
뜨거운 도구
메모장++7.3.1
사용하기 쉬운 무료 코드 편집기
SublimeText3 중국어 버전
중국어 버전, 사용하기 매우 쉽습니다.
스튜디오 13.0.1 보내기
강력한 PHP 통합 개발 환경
드림위버 CS6
시각적 웹 개발 도구
SublimeText3 Mac 버전
신 수준의 코드 편집 소프트웨어(SublimeText3)
뜨거운 주제
7469
15
1376
52
77
11
48
19
19
29
explorer.exe 프로세스가 무엇인지 설명하세요.
Feb 18, 2024 pm 12:11 PM
explorer.exe는 어떤 프로세스인가요? 우리는 Windows 운영체제를 사용하다 보면 "explorer.exe"라는 용어를 자주 듣게 됩니다. 이 기사에서는 explorer.exe 프로세스가 무엇인지, 그 기능과 효과에 대해 자세히 설명합니다. 우선 explorer.exe는 Windows 운영체제의 핵심 프로세스로 Windows 탐색기(Window)를 관리하고 제어하는 역할을 합니다.
COM대리인의 절차는 어떻게 되나요?
Sep 14, 2022 pm 02:56 PM
"com surrogate"는 "C:\Windows\System32\dllhost.exe"의 프로세스입니다. 이 프로세스가 발생하면 일반적으로 이 프로세스가 많은 공간을 차지하며 작동하지 않는다는 의미입니다. 컴퓨터가 파일 아이콘을 로드하는 중이기 때문에 컴퓨터가 멈추는 경우가 있습니다. 컴퓨터 속성 설정에서 문제를 해결할 수 있습니다.
ccsvchst.exe는 어떤 프로세스인가요?
Feb 19, 2024 pm 11:33 PM
ccsvchst.exe는 SEP(Symantec Endpoint Protection) 소프트웨어의 일부인 공통 프로세스 파일이며, SEP는 잘 알려진 네트워크 보안 회사인 Symantec이 개발한 엔드포인트 보호 솔루션입니다. 소프트웨어의 일부로 ccsvchst.exe는 SEP 관련 프로세스를 관리하고 모니터링하는 역할을 담당합니다. 먼저 SymantecEndpointProtection(
Linux에서 좀비 프로세스를 올바르게 종료하는 방법
Feb 19, 2024 am 10:40 AM
Linux 시스템에서 좀비 프로세스는 종료되었지만 여전히 시스템에 남아 있는 특수 프로세스입니다. 좀비 프로세스는 리소스를 많이 소모하지 않지만 너무 많으면 시스템 리소스가 고갈될 수 있다. 이 기사에서는 시스템의 정상적인 작동을 보장하기 위해 좀비 프로세스를 올바르게 제거하는 방법을 소개합니다. 1Linux 좀비 프로세스 자식 프로세스가 작업을 완료한 후 부모 프로세스가 제때에 상태를 확인하지 않으면 자식 프로세스는 좀비 프로세스가 됩니다. 하위 프로세스는 상위 프로세스의 확인을 기다리고 있으며 시스템은 완료될 때까지 이를 재활용하지 않습니다. 그렇지 않으면 좀비 프로세스가 시스템에서 계속 정지됩니다. 시스템에 좀비 프로세스가 있는지 확인하려면 top 명령을 실행하여 실행 중인 모든 프로세스와 가능한 좀비 프로세스를 볼 수 있습니다. 'top' 명령의 결과는 Linux의 위 그림에서 확인할 수 있습니다.
Linux 프로세스 우선순위 조정 방법에 대한 자세한 설명
Mar 15, 2024 am 08:39 AM
Linux 프로세스 우선순위 조정 방법에 대한 자세한 설명 Linux 시스템에서는 프로세스의 우선순위에 따라 시스템의 실행 순서와 리소스 할당이 결정됩니다. 프로세스의 우선순위를 합리적으로 조정하면 시스템의 성능과 효율성을 향상시킬 수 있습니다. 이 기사에서는 Linux에서 프로세스 우선순위를 조정하는 방법을 자세히 소개하고 구체적인 코드 예제를 제공합니다. 1. 프로세스 우선순위 개요 Linux 시스템에서 각 프로세스에는 그에 연관된 우선순위가 있습니다. 우선순위 범위는 일반적으로 -20~19입니다. 여기서 -20은 가장 높은 우선순위를 나타내고 19는
Windows 11에서 작업 관리자 프로세스 업데이트를 중지하고 작업을 더 쉽게 종료하는 방법
Aug 20, 2023 am 11:05 AM
Windows 11 및 Windows 10에서 작업 관리자 프로세스 업데이트를 일시 중지하는 방법 CTRL+창 키+Delete를 눌러 작업 관리자를 엽니다. 기본적으로 작업 관리자는 프로세스 창을 엽니다. 여기에서 볼 수 있듯이 모든 앱은 끝없이 돌아다니기 때문에 선택하려고 할 때 아래로 가리키는 것이 어려울 수 있습니다. 따라서 CTRL을 길게 누르면 작업 관리자가 일시 중지됩니다. 여전히 앱을 선택하고 아래로 스크롤할 수도 있지만 항상 CTRL 버튼을 누르고 있어야 합니다.
Linux의 프로세스가 왜 잠자기 상태입니까?
Mar 20, 2024 pm 02:09 PM
Linux의 프로세스가 왜 잠자기 상태입니까? Linux 운영 체제에서는 다양한 이유와 조건으로 인해 프로세스가 휴면 상태가 될 수 있습니다. 프로세스가 휴면 상태에 있다는 것은 프로세스가 일시적으로 중단되어 실행을 계속하기 위해 활성화되기 전에 특정 조건이 충족될 때까지 실행을 계속할 수 없음을 의미합니다. 다음으로 Linux에서 프로세스가 최대 절전 모드로 들어갈 때 발생하는 몇 가지 일반적인 상황을 자세히 소개하고 구체적인 코드 예제를 통해 설명하겠습니다. I/O가 완료되기를 기다리는 중: 프로세스가 I/O 작업(예: 읽기)을 시작할 때
Linux 시스템에 PHP 프로세스가 없는지 확인하는 방법
Mar 16, 2024 am 11:42 AM
"Linux 시스템에서 PHP 프로세스가 없는 감지 방법, 특정 코드 예제가 필요합니다." 웹 개발을 위해 Linux 시스템을 사용할 때 동적 페이지와 로직을 처리하기 위해 PHP 프로세스에 의존하는 경우가 많으며 때로는 PHP가 있는지 모니터링해야 할 수도 있습니다. 서버에서 프로세스를 수행합니다. 이 기사에서는 Linux 시스템에 PHP 프로세스가 있는지 여부를 감지하는 방법을 소개하고 구체적인 코드 예제를 제공합니다. PHP 프로세스를 감지하는 것이 필요한 이유는 무엇입니까? 웹 개발에서 PHP 프로세스는 PHP 프로세스를 구문 분석하고 실행하는 데 중요한 역할을 합니다.