Linux进程间通信(管道、消息队列、共享内存、信号、信号量)

目录

  • Linux进程间通信概述
  • 1.管道
    • 无名管道(pipe)
    • 有名管道(fifo)
  • 2.消息队列(msg)
    • 消息队列的通信原理
    • 消息队列相关api
    • 消息队列收发数据
    • 键值生成
    • 消息队列移除
  • 3.共享内存(shm)
  • 4.信号(sig)
    • 信号概述
    • 信号编程（入门）
    • 信号携带消息（高级）
  • 5.信号量(sem)
    • P、V操作(类似信号量lock、unlock)
  • 6.通信方式总结

Linux进程间通信概述

进程间通信（IPC，InterProcess Communication）是指在不同进程之间传播或交换信息。
IPC 的方式通常有管道（包括无名管道和命名管道）、消息队列、共享内存、信号、信号量、Socket、Streams 等。其中 Socket 和 Streams 支持不同主机上的两个进程 IPC。
在这里插入图片描述

1.管道

无名管道(pipe)

管道，通常指无名管道，是 UNIX 系统IPC最古老的形式。

特点：

1、它是半双工的（即数据只能在一个方向上流动），具有固定的读端（fd[0])和写端(fd[1])。

2、它只能用于具有亲缘关系的进程之间的通信（也是父子进程或者兄弟进程之间）。

3、它可以看成是一种特殊的文件，对于它的读写也可以使用普通的read、write 等函数。但是它不是普通的文件，并不属于其他任何文件系统，并且只存在于内存中。

4、管道中的数据读走就没了。

原型：

1 #include <unistd.h>
2 int pipe(int fd[2]);    // 返回值：若成功返回0，失败返回-1

当一个管道建立时，它会创建两个文件描述符：fd[0]为读而打开，fd[1]为写而打开。要关闭管道只需将这两个文件描述符关闭即可。如下图：
在这里插入图片描述
在这里插入图片描述
例子：
创建管道后，在父进程中写入，在子进程中读

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{int fd[2];pid_t pid;char readBuf[128];int nwrite;int nread;// int pipe(int pipefd[2]);if(pipe(fd) == -1){printf("创建管道失败\n");}pid=fork();//创建子进程if(pid == -1){printf("创建子进程失败\n");//1.在父进程写入}else if(pid > 0){printf("这是父进程\n");close(fd[0]);//关闭读文件//ssize_t write(int fd, const void *buf, size_t count);nwrite=write(fd[1],"hello from father process",strlen("hello from father process"));wait(NULL);//2.在子进程读}else{printf("这是子进程\n");close(fd[1]);//ssize_t read(int fd, void *buf, size_t count);nread=read(fd[0],readBuf,128);//如果度端没有内容，会阻塞等待printf("来自父进程的写入内容是：%s\n",readBuf);exit(0);}return 0;
}

注意： 管道为半双工通信，读和写操作在同一时间内只能进行一个，所以在读的时候要关闭写端，写的时候关闭读端。
运行结果：

在这里插入图片描述

有名管道(fifo)

FIFO，也称为命名管道，它是一种文件类型。

1、特点
FIFO可以在无关的进程之间交换数据，与无名管道不同。

FIFO有路径名与之相关联，它以一种特殊设备文件形式存在于文件系统中。

2、原型

1 #include <sys/stat.h>
2 // 返回值：成功返回0，出错返回-1
3 int mkfifo(const char *pathname, mode_t mode);

其中的 mode 参数与open函数中的 mode 相同。一旦创建了一个 FIFO，就可以用一般的文件I/O函数操作它。

当 open 一个FIFO时，是否设置非阻塞标志（O_NONBLOCK）的区别：

1、若没有指定O_NONBLOCK（默认），只读 open 要阻塞到某个其他进程为写而打开此 FIFO（参照下面的例子）。类似的，只写 open 要阻塞到某个其他进程为读而打开它。

2、若指定了O_NONBLOCK，则只读 open 立即返回。而只写 open 将出错返回 -1 如果没有进程已经为读而打开该 FIFO，其errno置ENXIO。

创建管道例子

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>int main()
{//int mkfifo(const char *pathname, mode_t mode);if(mkfifo("./file",0600) == -1 && errno != EEXIST){printf("mkfifo创建失败\n");perror("why:");}else{if(errno == EEXIST){printf("文件已经存在\n");}printf("mkfifo创建成功\n");}return 0;
}

使用有名管道通信的例子

read代码：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
int main()
{int nread;mkfifo("./file",0600);char buf[1024] = {0};int fd = open("./file",O_RDONLY);//若没有指定O_NONBLOCK（默认），只读 open 要阻塞到某个其他进程为写而打开此 FIFOprintf("open success\n");while(1){nread = read(fd,buf,1024);printf("read %d byte ,neirong:%s\n",nread,buf);}return 0;
}

write代码：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
int main()
{mkfifo("./file",0600);char *str = "this is a fifo demo!";int fd = open("./file",O_WRONLY);printf("open success\n");while(1){write(fd,str,strlen(str));sleep(1);}return 0;
}

运行read会阻塞，一直到运行write后read才会继续往下执行。

个人感觉很像文件操作，不过不用进行lseek等操作，内核知道这是管道操作，数据读出时管道数据清除。

2.消息队列(msg)

消息队列的通信原理

消息队列，是消息的链接表(结构体)，存放在内核中。一个消息队列由一个标识符（即队列ID）来标识。

特点
消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先级。

消息队列独立于发送与接收进程。进程终止时，消息队列及其内容并不会被删除（Linux内核机制进行管理）。

消息队列可以实现消息的随机查询（链表机制就是这样的）,消息不一定要以先进先出的次序读取,也可以按消息的类型读取。

消息队列的通信原理理解图：
在这里插入图片描述

消息队列相关api

1 #include <sys/msg.h>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);

在以下两种情况下，msgget将创建一个新的消息队列：

1、如果没有与键值key相对应的消息队列，并且flag中包含了IPC_CREAT标志位。
2、key参数为IPC_PRIVATE。

函数msgrcv在读取消息队列时，type参数有下面几种情况：

type == 0，返回队列中的第一个消息；
type > 0，返回队列中消息类型为 type 的第一个消息；
type < 0，返回队列中消息类型值小于或等于 type 绝对值的消息，如果有多个，则取类型值最小的消息。
可以看出，type值非 0 时用于以非先进先出次序读消息。也可以把 type 看做优先级的权值。（其他的参数解释，请自行Google之）

消息队列收发数据

readmsg

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
struct msgbuf {long mtype;       /* message type, must be > 0 */char mtext[128];    /* message data */
};int main()
{struct msgbuf readBuf;//int msgget(key_t key, int msgflg);int msgId=msgget(0x1234,IPC_CREAT|0777);//如果存在就打开，没有则创建权限是可读刻写可执行if(msgId == -1){printf("创建失败\n");}//int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);// ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);msgrcv(msgId,&readBuf,sizeof(readBuf.mtext),888,0);//0是阻塞方式printf("读取来自队列的内容：%s\n",readBuf.mtext);return 0;
}

sendmsg

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
struct msgbuf {long mtype;       /* message type, must be > 0 */char mtext[128];    /* message data */
};int main()
{struct msgbuf sendBuf={888,"this message from que"};;//int msgget(key_t key, int msgflg);int msgId=msgget(0x1234,IPC_CREAT|0777);//如果存在就打开，没有则创建权限是可读刻写可执行if(msgId == -1){printf("创建失败\n");}//int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);// ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);msgsnd(msgId,&sendBuf,strlen(sendBuf.mtext),0);//0是非阻塞return 0;
}

运行结果：
先运行readmsg阻塞在那等待发送消息
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

实现双方消息通信都能发送和接收

readmsg

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
struct msgbuf {long mtype;       /* message type, must be > 0 */char mtext[128];    /* message data */
};int main()
{struct msgbuf readBuf;struct msgbuf sendBuf={998,"thank you que, i have received"};//int msgget(key_t key, int msgflg);int msgId=msgget(0x1234,IPC_CREAT|0777);//如果存在就打开，没有则创建权限是可读刻写可执行if(msgId == -1){printf("创建失败\n");}//int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);// ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);msgrcv(msgId,&readBuf,sizeof(readBuf.mtext),888,0);//0是非阻塞方式printf("读取来自队列的内容：%s\n",readBuf.mtext);msgsnd(msgId,&sendBuf,strlen(sendBuf.mtext),0);//0是非阻塞printf("发送完毕\n");return 0;
}

sendmsg

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
struct msgbuf {long mtype;       /* message type, must be > 0 */char mtext[128];    /* message data */
};int main()
{struct msgbuf sendBuf={888,"this message from que"};struct msgbuf readBuf;//int msgget(key_t key, int msgflg);int msgId=msgget(0x1234,IPC_CREAT|0777);//如果存在就打开，没有则创建权限是可读刻写可执行if(msgId == -1){printf("创建失败\n");}//int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);// ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);msgsnd(msgId,&sendBuf,strlen(sendBuf.mtext),0);//0是非阻塞printf("发送完毕\n");msgrcv(msgId,&readBuf,sizeof(readBuf.mtext),998,0);//0是非阻塞方式printf("读取来自队列的内容：%s\n",readBuf.mtext);return 0;
}

在这里插入图片描述

键值生成

readmsg

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
struct msgbuf {long mtype;       /* message type, must be > 0 */char mtext[128];    /* message data */
};int main()
{struct msgbuf readBuf;struct msgbuf sendBuf={998,"thank you que, i have received"};//key_t ftok(const char *pathname, int proj_id);key_t key;key=ftok(".",'z');//"."当前路径， proj_id典型的用法是将一个ASCII码作为proj_id，随便取值都可以  内核这两者组合出一个键值printf("key = %x\n",key);//用16进制输出//int msgget(key_t key, int msgflg);int msgId=msgget(key,IPC_CREAT|0777);//如果存在就打开，没有则创建权限是可读刻写可执行if(msgId == -1){printf("创建失败\n");}//int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);// ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);msgrcv(msgId,&readBuf,sizeof(readBuf.mtext),888,0);//0是非阻塞方式printf("读取来自队列的内容：%s\n",readBuf.mtext);msgsnd(msgId,&sendBuf,strlen(sendBuf.mtext),0);//0是非阻塞printf("发送完毕\n");return 0;
}

sendmsg

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
struct msgbuf {long mtype;       /* message type, must be > 0 */char mtext[128];    /* message data */
};int main()
{struct msgbuf sendBuf={888,"this message from que"};struct msgbuf readBuf;key_t key;key=ftok(".",'z');//"."当前路径，proj_id典型的用法是将一个ASCII码作为proj_idprintf("key = %x\n",key);//用16进制输出//int msgget(key_t key, int msgflg);int msgId=msgget(key,IPC_CREAT|0777);//如果存在就打开，没有则创建权限是可读刻写可执行if(msgId == -1){printf("创建失败\n");}//int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);// ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);msgsnd(msgId,&sendBuf,strlen(sendBuf.mtext),0);//0是非阻塞printf("发送完毕\n");msgrcv(msgId,&readBuf,sizeof(readBuf.mtext),998,0);//0是非阻塞方式printf("读取来自队列的内容：%s\n",readBuf.mtext);return 0;
}

在这里插入图片描述

消息队列移除

int msgctl(int msqid, int cmd, struct msqid_ds *buf);

struct msqid_ds *buf这里我们一般写NULL
CMD类型参照下图（箭头指的就是i用的最多的，把消息队列生成的链表在内核里移除）：
在这里插入图片描述
例如：
readmsg

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
struct msgbuf {long mtype;       /* message type, must be > 0 */char mtext[128];    /* message data */
};int main()
{struct msgbuf readBuf;struct msgbuf sendBuf={998,"thank you que, i have received"};//key_t ftok(const char *pathname, int proj_id);key_t key;key=ftok(".",'z');//"."当前路径，proj_id典型的用法是将一个ASCII码作为proj_idprintf("key = %x\n",key);//用16进制输出//int msgget(key_t key, int msgflg);int msgId=msgget(key,IPC_CREAT|0777);//如果存在就打开，没有则创建权限是可读刻写可执行if(msgId == -1){printf("创建失败\n");}//int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);// ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);msgrcv(msgId,&readBuf,sizeof(readBuf.mtext),888,0);//0是非阻塞方式printf("读取来自队列的内容：%s\n",readBuf.mtext);msgsnd(msgId,&sendBuf,strlen(sendBuf.mtext),0);//0是非阻塞printf("发送完毕\n");msgctl(msgId,IPC_RMID,NULL);return 0;
}

sendmsg

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
struct msgbuf {long mtype;       /* message type, must be > 0 */char mtext[128];    /* message data */
};int main()
{struct msgbuf sendBuf={888,"this message from que"};struct msgbuf readBuf;key_t key;key=ftok(".",'z');//"."当前路径，proj_id典型的用法是将一个ASCII码作为proj_idprintf("key = %x\n",key);//用16进制输出//int msgget(key_t key, int msgflg);int msgId=msgget(key,IPC_CREAT|0777);//如果存在就打开，没有则创建权限是可读刻写可执行if(msgId == -1){printf("创建失败\n");}//int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);// ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);msgsnd(msgId,&sendBuf,strlen(sendBuf.mtext),0);//0是非阻塞printf("发送完毕\n");msgrcv(msgId,&readBuf,sizeof(readBuf.mtext),998,0);//0是非阻塞方式printf("读取来自队列的内容：%s\n",readBuf.mtext);//int msgctl(int msqid, int cmd, struct msqid_ds *buf);msgctl(msgId,IPC_RMID,NULL);return 0;
}

在这里插入图片描述

3.共享内存(shm)

共享内存（Shared Memory），指两个或多个进程共享一个给定的存储区。

特点

  • 共享内存是最快的一种 IPC，因为进程是直接对内存进行存取。

  • 因为多个进程可以同时操作，所以需要进行同步。

信号量+共享内存通常结合在一起使用（最后一节讲解），信号量用来同步对共享内存的访问。

和消息队列的区别：

消息队列就像两个人聊天，一方要将要说的话写在一张纸上放入箱子里，另外一个人去箱子里取出来阅读。这个箱子（消息队列）不会自行销毁，要调用msgctl才可以。

共享内存就好像两个学生在上课的时候，由于不能说话，就只好拿一个本子来聊天，这个本子就相当于共享的内存，双方可以同时看到纸上的内容。比消息队列效率高。调用shmctl删除共享内存。

在这里插入图片描述

相关api原型

1 #include <sys/shm.h>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);

参数说明：

key为ftok生成的键值
size为共享内存的长度，以字节为单位
当用shmget函数创建一段共享内存时，必须指定其 size；而如果引用一个已存在的共享内存，则将 size 指定为0 。
flag为所需要的操作和权限，可以用来创建一个共享存储空间并返回一个标识符或者获得一个共享标识符。
----flag的值为IPC_CREAT：如果不存在key值的共享存储空间，且权限不为0，则创建共享存储空间，并返回一个共享存储标识符。如果存在，则直接返回共享存储标识符。
----flag的值为 IPC_CREAT |IPC_EXCL：如果不存在key值的共享存储空间，且权限不为0，则创建共享存储空间，并返回一个共享存储标识符。如果存在，则产生错误。
cmd 常用的是IPC_RMID从系统中删除该共享内存

例子
创建共享内存并写入数据

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>int main()
{key_t key;char *shmaddr;// key_t ftok(const char *pathname, int proj_id);key=ftok(".",2);printf("key = %x\n",key);//int shmget(key_t key, size_t size, int shmflg);//创建或获取一个共享内存：成功返回共享内存ID，失败返回-1int shmId=shmget(key,1024*4,IPC_CREAT|0666);//共享内存大小必须以字节为单位if(shmId == -1){printf("创建共享内存失败\n");exit(-1);//异常退出}//void *shmat(int shmid, const void *shmaddr, int shmflg);//连接共享内存到当前进程的地址空间：成功返回指向共享内存的指针，失败返回-1shmaddr=shmat(shmId,0,0);//挂载映射，如果引用一个已存在的共享内存（上方改革创建），则将 size 指定为0 printf("shmat ok\n");strcpy(shmaddr,"hello sharemessage");sleep(5);//int shmdt(const void *shmaddr);// 断开与共享内存的连接shmdt(shmaddr);//int shmctl(int shmid, int cmd, struct shmid_ds *buf);//控制共享内存的相关信息：成功返回0，失败返回-1shmctl(shmId,IPC_RMID,0);//IPC_RMID删除消息队列printf("退出\n");return 0;
}

读共享内存的内容

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>int main()
{key_t key;char *shmaddr;// key_t ftok(const char *pathname, int proj_id);key=ftok(".",2);printf("key = %x\n",key);//int shmget(key_t key, size_t size, int shmflg);//创建或获取一个共享内存：成功返回共享内存ID，失败返回-1int shmId=shmget(key,1024*4,0);//只要打开就行不必创建if(shmId == -1){printf("创建共享内存失败\n");exit(-1);//异常退出}//void *shmat(int shmid, const void *shmaddr, int shmflg);//连接共享内存到当前进程的地址空间：成功返回指向共享内存的指针，失败返回-1shmaddr=shmat(shmId,0,0);//挂载映射，如果引用一个已存在的共享内存,则将 size 指定为0 printf("shmat ok\n");printf("内容是：%s\n",shmaddr);//int shmdt(const void *shmaddr);//断开与共享内存的连接shmdt(shmaddr);return 0;
}

在这里插入图片描述

4.信号(sig)

本节参照博文：https://www.jianshu.com/p/f445bfeea40a

信号概述

1.信号：对Linux来说就是软中断，与单片机的硬件中断（串口）类似。如在linux中输入 ctrl+c 来停止一个程序

2.信号的名字与编号：可在linux中通过 kill -l 查询（Linux系统一共有64个信号，编号1-64。不存在0信号，0信号有特殊的应用：在系统级的应用中被占用）

在这里插入图片描述

部分信号的说明：

2)SIGINT：ctrl+c 终止信号

3)SIGQUIT：ctrl+\ 终止信号

20)SIGTSTP:ctrl+z 暂停信号

26)SIGALRM：闹钟信号 收到此信号后定时结束，结束进程

17)SIGCHLD：子进程状态改变，父进程收到信号

9)SIGKILL：杀死信号

3.信号处理的三种方式：忽略，捕捉和默认动作

1、忽略：就跟字面意思一样忽略掉它（注意：SIGKILL,SIGSTOP不能被忽略）

2、捕捉：就是一些信号处理的函数，然后让这个函数告诉内核，当信号产生时，内核调用该函数，实现某种信号的处理

3、默认动作：每个信号都有其对应的默认的处理动作，当触发了某种信号，系统就会立刻去执行。

4.信号的使用

其实对于常用的 kill 命令就是一个发送信号的工具，kill -9 PID或者使用命令kill -SIGKILL PID （二者作用一样）来杀死进程。比如，我在后台运行了一个 top 工具，通过 ps 命令可以查看他的 PID，通过 kill -9 来发送了一个终止进程的信号来结束了 top 进程。如果查看信号编号和名称，可以发现9对应的是 9) SIGKILL，正是杀死该进程的信号。而以下的执行过程实际也就是执行了9号信号的默认动作——杀死进程。

对于信号来说，最大的意义不是为了杀死信号，而是实现一些异步通讯（即信号处理方式第二种–捕捉）的手段，那么如何来自定义信号的处理函数呢？

信号编程（入门）

信号处理函数的注册(信号绑定)：signal (入门),sigaction(高级，可携带信号)
信号处理发送函数： kill （入门）, sigqueue（高级，可携带信号）

信号绑定

#include <stdio.h>
#include <signal.h>//      typedef定义了一种类型sighandler_t//typedef void (*sighandler_t)(int);//函数指针(指向函数的指针)，无返回值，传入参数为一个int型//sighandler_t signal(int signum, sighandler_t handler);
//     返回这种类型                   带有_t表示结构体  函数指针变量
void handler(int signum){switch(signum){case 2:printf("get SIGINT,signum=%d\n",signum);break;case 9:printf("get SIGKILL,signum=%d\n",signum);break;case 10:printf("get SIGUSR1,signum=%d\n",signum);break;}printf("never quit\n");
}int main(){//函数指针 指向函数signal(SIGINT,handler);//捕捉信号 SIGINT是ctrl c的指令signal(SIGKILL,handler);signal(SIGUSR1,handler);for(;;);//等于while(1);return 0;
}

编译运行，在键盘上输入 ctrl+c，结果为：
在这里插入图片描述
信号发送（杀死程序的信号 SIGKILL）

#include <stdio.h>
#include <signal.h>
#include <sys/types.h>
#include <stdlib.h>//typedef void (*sighandler_t)(int);//sighandler_t signal(int signum, sighandler_t handler);int main(int argc,char **argv)
{int signum;int pid;char cmd[128]={0};signum=atoi(argv[1]);//将字符串str转换成一个整数并返回结果pid=atoi(argv[2]);printf("signum=%d pid=%d\n",signum,pid);// int kill(pid_t pid, int sig);//方法一：//kill(pid,signum);   发送信号x//方法二 system调用脚本sprintf(cmd,"kill -%d %d",signum,pid);system(cmd);printf("发送指令成功\n");return 0;
}

运行结果：
在这里插入图片描述
信号的忽略：

signal(SIGINT,SIG_IGN)//可以忽略掉ctrl c 的信号

信号携带消息（高级）

信号携带消息思路：

发信号

1.用什么发 sigqueue()
2.怎么发消息

#include <signal.h>//发给谁   发什么信号(比如上面讲的信号编号9 10等)  
int sigqueue(pid_t pid, int sig, const union sigval value);
union sigval {                   //发送的消息（接收端也是用的这个联合体）  int   sival_int;//发送整型void *sival_ptr;//发送字符串};

收信号

1.用什么绑定函数（以及收到信号如何处理动作）sigaction()
2.如何读出消息

#include <signal.h>
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
//sigactio(),会依照参数signum指定的信号编号来设置该信号的处理函数
//const struct sigaction *act,你要做什么
//struct sigaction *oldact，是否备份，不备份用NULLstruct sigaction {   凡是带有_t说明是个结构体void       (*sa_handler)(int); //信号处理程序，不接受额外数据，和signal()的参数handler一样了 SIG_IGN 为忽略，SIG_DFL 为默认动作void       (*sa_sigaction)(int, siginfo_t *, void *); //信号处理程序，能够接受额外数据和sigqueue配合使用sigset_t   sa_mask;//阻塞关键字的信号集(默认阻塞)，可以再调用捕捉函数之前，把信号添加到信号阻塞字，信号捕捉函数返回之前恢复为原先的值。int        sa_flags;//配置为SA_SIGINFO这个宏表示能够接受数据};
//回调函数句柄sa_handler、sa_sigaction只能任选其一siginfo_t {int      si_signo;    /* Signal number */int      si_errno;    /* An errno value */int      si_code;     /* Signal code */int      si_trapno;   /* Trap number that causedhardware-generated signal(unused on most architectures) */pid_t    si_pid;      /* Sending process ID */谁发的uid_t    si_uid;      /* Real user ID of sending process */int      si_status;   /* Exit value or signal */clock_t  si_utime;    /* User time consumed */clock_t  si_stime;    /* System time consumed */sigval_t si_value;    /* Signal value */接收的数据 是个联合体 信号发送函数使用这个联合体int      si_int;      /* POSIX.1b signal */数据void    *si_ptr;      /* POSIX.1b signal */int      si_overrun;  /* Timer overrun count; POSIX.1b timers */int      si_timerid;  /* Timer ID; POSIX.1b timers */void    *si_addr;     /* Memory location which caused fault */int      si_band;     /* Band event */int      si_fd;       /* File descriptor */
}

信号携带消息编程实现

收信号nicesignal.c

#include <stdio.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
/*struct sigaction {void     (*sa_handler)(int);void     (*sa_sigaction)(int, siginfo_t *, void *);sigset_t   sa_mask;int        sa_flags;void     (*sa_restorer)(void);};*/void     handler(int signum, siginfo_t *info, void *context)//info里面的参数可以通过man手册查询
{printf("signum=%d\n",signum);if(context != NULL){printf("get data=%d\n",info->si_int);printf("get data=%d\n",info->si_value.sival_int);//和上面一样换了种方式printf("发送者的pid=%d\n",info->si_pid);}
}int main()
{struct sigaction act;printf("pid=%d\n",getpid());act.sa_sigaction=handler;act.sa_flags=SA_SIGINFO;//能够获取到信息信息//int sigaction(int signum, const struct sigaction *act,struct sigaction *oldact);sigaction(SIGUSR1,&act,NULL);//第三个是参数是备份的这边写NULL SIGUSR1对应的编号为10！！！printf("22");while(1);return 0;
}

发信号niceSendSig.c

#include <stdio.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
int main(int argc,char **argv)
{int signum;int pid;signum=atoi(argv[1]);//atoi把字符串转化为整形pid=atoi(argv[2]);//接收进程的pid号union sigval value;value.sival_int=100;//发送一个整型数100的消息/*union sigval {int   sival_int;void *sival_ptr;  发送字符的话把地址传进来};*///int sigqueue(pid_t pid, int sig, const union sigval value);sigqueue(pid,signum,value);printf("我的pid是:%d\n",getpid());printf("发送完毕\n");return 0;
}

在这里插入图片描述

在这里插入图片描述

5.信号量(sem)

在这里插入图片描述

1.信号量：

信号量（Semaphore是一个计数器，用于实现进程间的互斥与同步，不用于存储进程间的通信数据

2.特点：

(1).用于进程间同步，若要在进程间传递数据需要结合共享内存

(2).信号量是基于PV操作，程序对信号量是原子操作

所谓原子操作，就是“不可中断的一个或一系列操作”,也就是不会被线程调度机制打断的操作

(3).对信号量的操作不仅限于对信号的+1，-1，可以是任意数（视频没讲）

P、V操作(类似信号量lock、unlock)

可以这样理解：一间房间（临界资源）的门前有一个盒子，盒子里有钥匙（信号量），一个人拿了钥匙（P操作），开了门并走进了房间，且门外还有人等着，得等进去的人出来放钥匙（V操作），这个人才能拿钥匙（P操作）进入房间

多道程序系统中存在许多进程，它们共享各种资源，然而有很多资源一次只能供一个进程使用。一次仅允许一个进程使用的资源称为临界资源。许多物理设备都属于临界资源，如输入机、打印机、磁带机等。

4.相关api
最简单的信号量是只能取 0 和 1 的变量，这也是信号量最常见的一种形式，叫做二值信号量（Binary Semaphore）。而可以取多个正整数的信号量被称为通用信号量。

Linux 下的信号量函数都是在通用的信号量数组上进行操作，而不是在一个单一的二值信号量上进行操作。

1 #include <sys/sem.h>
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, ...);

例子
目前是没有锁的状态，父进程想拿锁，在这边等待，然后子进程有锁直接放回，父进程得到锁后再运行。相当于不使用前面学习的wait方式保证子进程先运行，因为没有锁父进程卡在拿锁那边。

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdlib.h>
#include <unistd.h>//semctl函数第三个参数cmd的宏要求后面定义一个联合体
union semun {      int              val;    /* Value for SETVAL */struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */unsigned short  *array;  /* Array for GETALL, SETALL */struct seminfo  *__buf;  /* Buffer for IPC_INFO(Linux-specific) */
};void pGetKey(int semid)//p操作“拿锁”
{struct sembuf set;/*sops[0].sem_num = 0;         //Operate on semaphore 0 sops[0].sem_op = 0;       		// Wait for value to equal 0 sops[0].sem_flg = 0;*/set.sem_num=0;//信号量编号 操作第几个信号量（锁） 这里就一个set.sem_op=-1;//拿锁set.sem_flg=SEM_UNDO;//If an operation specifies SEM_UNDO, it will be automatically undone when the process terminates.//SEM_UNDO设置为当进程截止的时候，取消对锁的操作//int semop(int semid, struct sembuf *sops, size_t nsops); 对信号量组进行操作，改变信号量的值：成功返回0，失败返回-1semop(semid,&set,1);//1代表第二个参数的个数printf("拿锁\n");
}void vPutBackKey(int semid)//v操作“放回锁”
{struct sembuf set;/*sops[0].sem_num = 0;         //Operate on semaphore 0 sops[0].sem_op = 0;       		// Wait for value to equal 0 sops[0].sem_flg = 0;*/set.sem_num=0;set.sem_op=1;//放回锁set.sem_flg=SEM_UNDO;//If an operation specifies SEM_UNDO, it will be automatically undone when the process terminates.//int semop(int semid, struct sembuf semoparray[], size_t numops); 对信号量组进行操作，改变信号量的值：成功返回0，失败返回-1semop(semid,&set,1);printf("放回锁\n");
}int main(int argc, char const *argv[])
{key_t key;int semid;key=ftok(".",2);union semun initsem;initsem.val=0;//初始是没有锁状态//int semget(key_t key, int nsems, int semflg);创建或获取一个信号量组：若成功返回信号量集ID，失败返回-1semid=semget(key,1,IPC_CREAT|0666);//1:信号量组中有几个信号量 这边选择1个，IPC_CREAT|0666：如果有就获取没有就创建信号量组，权限可读可写可执行//int semctl(int semid, int sem_num, int cmd, ...); 控制信号量的相关信息semctl(semid,0,SETVAL,initsem);//初始化信号量，int sem_num是代表操作第几个信号量，我这边写0代表操作第一个信号量（和数组一样 第一个从0开始），多个信号量要构造数组//cmd可以通过man手册差相关的宏，SETVAL设置信号量的初值,设置为initsem(联合体),里面有1把琐int pid = fork();//创建子进程if(pid > 0){//去拿锁pGetKey(semid);//拿锁  P操作printf("这是父进程\n");vPutBackKey(semid);//放回锁	semctl(semid,0,IPC_RMID);//销毁锁	}else if(pid == 0){printf("这是子进程\n");vPutBackKey(semid);//放锁 V操作}else{printf("创建失败\n");}return 0;
}

锁初始化为0，子进程先运行，运行结束放锁（1），父进程拿锁（-1），然后放锁（1），最后销毁锁。
在这里插入图片描述

6.通信方式总结

1.管道（无名管道）：速度慢，容量有限，只有父子进程能通讯

2.FIFO（有名管道）：任何进程间都能通讯，但速度慢

3.消息队列：容量受到系统限制，且要注意第一次读的时候，要考虑上一次没有读完数据的问题

4.信号量：不能传递数据，只能用来同步（P操作、V操作）

5.共享内存区：能够很容易控制容量，速度快，但要保持同步（和信号量结合使用），比如一个进程在写的时候，另一个进程要注意读写的问题，相当于线程中的线程安全。当然，共享内存区同样可以用作线程间通讯，不过没这个必要，线程间本来就已经共享了同一进程内的一块内存
在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/266093.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Eclipse上GIT插件EGIT使用手册之五_查看历史记录

Eclipse上GIT插件EGIT使用手册之五_查看历史记录

Team -> Show in history可以查看版本历史提交记录 可以选择对比模式
阅读更多...
solr7.4 centos7安装

solr7.4 centos7安装

环境&#xff1a;centos7、JDK1.8、solr 自带Jetty启动 一、安装JDK1.8环境 1、下载JDK jdk-8u172-linux-x64.rpm 下载地址&#xff1a;http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html 2、安装JDK rpm -ivh jdk-8u131-linux-x64.rpm 3、…
阅读更多...
How to Fix an App that Crashes in Release but n...

How to Fix an App that Crashes in Release but n...

2019独角兽企业重金招聘Python工程师标准>>> 今天在测试app时&#xff0c;发现app store上版本有奔溃现象&#xff0c;但是直接用xcode跑本地程序没问题。猜测release&debug版本造成的&#xff0c;后发现targets的 optimization level设置问题&#xff0c;将rel…
阅读更多...
斐波那契数列c++代码_轮到你了，斐波那契数列！

斐波那契数列c++代码_轮到你了，斐波那契数列！

前阵子&#xff0c;日剧“轮到你了”终于大结局了&#xff0c;虽然结局有点一言难尽&#xff0c;但黑岛和二阶堂两个学霸之间的爱情&#xff0c;还是很甜呢呐&#xff01;两个学霸之间的默契的斐波那契数列也被许多网友认为是凶手行凶的依据。到底这数列有啥神奇之处&#xff0…
阅读更多...
悖论对计算机科学影响,引力波的发现对计算机科学有什么意义？

悖论对计算机科学影响,引力波的发现对计算机科学有什么意义？

满意答案saihdfa2016.02.28采纳率&#xff1a;43% 等级&#xff1a;10已帮助&#xff1a;420人引力波的发现对计算机科学的意义&#xff1a;允许引力波携带有更多的之前从未被观测过的信息。引力波有两个非常重要而且比较独特的性质。第一&#xff1a;不需要任何的物质存在于…
阅读更多...
全国计算机等级考试题库二级C操作题100套（第98套）

全国计算机等级考试题库二级C操作题100套（第98套）

更多干货推荐可以去牛客网看看&#xff0c;他们现在的IT题库内容很丰富&#xff0c;属于国内做的很好的了&#xff0c;而且是课程刷题面经求职讨论区分享&#xff0c;一站式求职学习网站&#xff0c;最最最重要的里面的资源全部免费&#xff01;&#xff01;&#xff01;点击进…
阅读更多...
光动能表怎么维护_西铁城手表推荐，西铁城光动能表推荐选购指南

光动能表怎么维护_西铁城手表推荐，西铁城光动能表推荐选购指南

有的朋友们在京东上面看到款式多样的西铁城手表和西铁城光动能手表的时候&#xff0c;不知道怎么选择哪一款适合自己佩戴的&#xff1f;那么今天我就通过这篇文章&#xff0c;跟大家详细的分享一下关于西铁城手表的知识。让大家在选购的时候更加清晰明了的知道哪一款适合自己。…
阅读更多...
python-2:工欲善其事，必先利其器 修改jupyter保存文件目录（亲测）

python-2:工欲善其事，必先利其器 修改jupyter保存文件目录（亲测）

在桌面上创建 Jupyter Notebook快捷方式图标.将打开的Jupyter Notebook程序关闭&#xff0c;然后找到桌面快捷方式&#xff0c;右键>属性&#xff0c;然后把目标后面输入框最后的“%USERPROFILE%”这个参数去掉后&#xff0c;确定。否则之后做的其它修改无法生效。打开 cmd …
阅读更多...
全国计算机等级考试题库二级C操作题100套（第99套）

全国计算机等级考试题库二级C操作题100套（第99套）

更多干货推荐可以去牛客网看看&#xff0c;他们现在的IT题库内容很丰富&#xff0c;属于国内做的很好的了&#xff0c;而且是课程刷题面经求职讨论区分享&#xff0c;一站式求职学习网站&#xff0c;最最最重要的里面的资源全部免费&#xff01;&#xff01;&#xff01;点击进…
阅读更多...
OSPF 邻接关系建立

OSPF 邻接关系建立

阅读更多...
全国计算机等级考试题库二级C操作题100套（第100套）

全国计算机等级考试题库二级C操作题100套（第100套）

更多干货推荐可以去牛客网看看&#xff0c;他们现在的IT题库内容很丰富&#xff0c;属于国内做的很好的了&#xff0c;而且是课程刷题面经求职讨论区分享&#xff0c;一站式求职学习网站&#xff0c;最最最重要的里面的资源全部免费&#xff01;&#xff01;&#xff01;点击进…
阅读更多...
安卓APP_ 其他（1） —— 程序的签名打包并在手机上运行

安卓APP_ 其他（1） —— 程序的签名打包并在手机上运行

摘自&#xff1a;安卓APP_ 其他&#xff08;1&#xff09; —— 程序的签名打包并在手机上运行 作者&#xff1a;丶PURSUING 发布时间&#xff1a; 2021-03-29 20:58:26 网址&#xff1a;https://blog.csdn.net/weixin_44742824/article/details/115310388 刚学到第四个控件&am…
阅读更多...
计算机数据恢复专业,专业电脑数据恢复软件哪个好

计算机数据恢复专业,专业电脑数据恢复软件哪个好

原标题&#xff1a;专业电脑数据恢复软件哪个好在我们日常清理电脑时&#xff0c;有时会意外删除一些有用的文件&#xff0c;比如重要文件、照片等。这时就需要使用数据恢复软件尝试恢复数据。EasyRecovery是一款强大有效实现数据恢复的软件&#xff0c;软件占用空间小&#xf…
阅读更多...
C#开发移动应用系列(2.使用WebView搭建WebApp应用)

C#开发移动应用系列(2.使用WebView搭建WebApp应用)

C#开发移动应用系列(2.使用WebView搭建WebApp应用) 原文:C#开发移动应用系列(2.使用WebView搭建WebApp应用)前言上篇文章地址:C#开发移动应用系列(1.环境搭建) 嗯..一周了 本来打算2天一更的 - - ,结果 出差了..请各位原谅.. 今天我们来讲一下使用WebView搭建WebApp应用. 说明一…
阅读更多...
new 一个模板、类_Java必备基础-类(Class)

new 一个模板、类_Java必备基础-类(Class)

你好&#xff0c;我是goldsunC让我们一起进步吧&#xff01;类上一篇文章介绍了Java的基础数据类型和引用数据类型中的数组&#xff0c;引用数据类型除了数组之外&#xff0c;还包括类和接口。那什么是引用数据类型呢&#xff1f;看个例子&#xff1a;public class Test {publi…
阅读更多...
华北电力大学计算机科学与技术考研,华北电力大学吴克河教授谈计算机科学与技术专业...

华北电力大学计算机科学与技术考研,华北电力大学吴克河教授谈计算机科学与技术专业...

导语&#xff1a;读万卷书不如行万里路&#xff0c;行万里路不如名师点悟。选导师也是个大学问——择师而师&#xff0c;不可草草。为此我们特邀请众多精英导师&#xff0c;我们期待他们的亲身经历和观点建议&#xff0c;能够给考研路上的你以参考……华北电力大学计算机科学与…
阅读更多...
安卓APP_ 控件（4）—— ImageView

安卓APP_ 控件（4）—— ImageView

摘自&#xff1a;安卓APP_ 控件&#xff08;4&#xff09;—— ImageView 作者&#xff1a;丶PURSUING 发布时间&#xff1a; 2021-03-29 21:52:06 网址&#xff1a;https://blog.csdn.net/weixin_44742824/article/details/115311375 开篇&#xff1a;安卓APP_ 控件&#xff0…
阅读更多...
使用python的openpyxl模块操作excel

使用python的openpyxl模块操作excel

openpyxl&#xff08;可读写excel表&#xff09;专门处理Excel2007及以上版本产生的xlsx文件&#xff0c;xls和xlsx之间转换容易 openpyxl的安装 模块的引入 from openpyxl import Workbook from openpyxl.styles import Color, Font, Alignment from openpyxl.styles import B…
阅读更多...
安卓APP_ 控件（5）—— ProgressBar

安卓APP_ 控件（5）—— ProgressBar

摘自&#xff1a;安卓APP_ 控件&#xff08;5&#xff09;—— ProgressBar 作者&#xff1a;丶PURSUING 发布时间&#xff1a; 2021-03-31 13:03:07 网址&#xff1a;https://blog.csdn.net/weixin_44742824/article/details/115313496 控件ProgressBar就是对进度条的设定&…
阅读更多...
sql 写query_为什么需要动态SQL

sql 写query_为什么需要动态SQL

为什么需要动态SQL在使用 EF或者写 SQL语句时&#xff0c;查询条件往往是这样一种非常常见的逻辑&#xff1a;如果客户填了查询信息&#xff0c;则查询该条件&#xff1b;如果客户没填&#xff0c;则返回所有数据。我常常看到很多人解决这类问题时使用了错误的静态 SQL的解决办…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023