参考：https://blog.csdn.net/wh_sjc/article/details/70283843
一、管道
管道，通常指无名管道，是 UNIX 系统IPC最古老的形式。
特点：
它是半双工的（即数据只能在一个方向上流动），具有固定的读端和写端。
它只能用于具有亲缘关系的进程之间的通信（也是父子进程或者兄弟进程之间）。
它可以看成是一种特殊的文件，对于它的读写也可以使用普通的read、write 等函数。但是它不是普通的文件，并不属于其他任何文件系统，并且只存在于内存中。
原型
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);
创建这个管道
#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;
}
例子
读
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
int main()
{
int i;
char readBuf[100];
//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");
}
int fd=open("./file",O_RDONLY);//o_rdonly read only 只读
printf("read打开成功\n");
while(1){
int nread=read(fd,readBuf,100);
printf("read %d个字节来自fifo,内容是:%s \n",nread,readBuf);
i++;
if(i == 5){
break;
}
}
close(fd);
return 0;
}
写
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <stdlib.h>
int main()
{
int i;
char *str;
int fd=open("./file",O_WRONLY);//o_wronly write only 只写bai
printf("打开write成功\n");
str=(char *)malloc(128);
printf("请输入字符串\n");
gets(str);
for(i=0;i<5;i++){
int nwrite=write(fd,str,strlen(str));
sleep(1);
}
close(fd);
return 0;
}
三、消息队列
消息队列，是消息的链接表，存放在内核中。一个消息队列由一个标识符（即队列ID）来标识。
特点
消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先级。
消息队列独立于发送与接收进程。进程终止时，消息队列及其内容并不会被删除。
消息队列可以实现消息的随机查询,消息不一定要以先进先出的次序读取,也可以按消息的类型读取。
原型
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将创建一个新的消息队列：
如果没有与键值key相对应的消息队列，并且flag中包含了IPC_CREAT标志位。
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
#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_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);
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);
有那些CMD
箭头指的就是i用的最多的，把消息队列生成的链表在内核里移除
struct msqid_ds *buf这里我们一般写NULL
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");
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_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);
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;
}
四、共享内存
共享内存（Shared Memory），指两个或多个进程共享一个给定的存储区。
特点
共享内存是最快的一种 IPC，因为进程是直接对内存进行存取。
因为多个进程可以同时操作，所以需要进行同步。
信号量+共享内存通常结合在一起使用，信号量用来同步对共享内存的访问。
原型
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);
当用shmget函数创建一段共享内存时，必须指定其 size；而如果引用一个已存在的共享内存，则将 size 指定为0 。
当一段共享内存被创建以后，它并不能被任何进程访问。必须使用shmat函数连接该共享内存到当前进程的地址空间，连接成功后把共享内存区对象映射到调用进程的地址空间，随后可像本地空间一样访问。
shmdt函数是用来断开shmat建立的连接的。注意，这并不是从系统中删除该共享内存，只是当前进程不能再访问该共享内存而已。
shmctl函数可以对共享内存执行多种操作，根据参数 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，失败返回-1
int shmId=shmget(key,1024*4,IPC_CREAT|0666);//共享内存大小必须以兆为单位
if(shmId == -1){
printf("创建共享内存失败\n");
exit(-1);//异常退出
}
//void *shmat(int shmid, const void *shmaddr, int shmflg);
//连接共享内存到当前进程的地址空间：成功返回指向共享内存的指针，失败返回-1
shmaddr=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，失败返回-1
shmctl(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，失败返回-1
int shmId=shmget(key,1024*4,0);//只要打开就行不必创建
if(shmId == -1){
printf("创建共享内存失败\n");
exit(-1);//异常退出
}
//void *shmat(int shmid, const void *shmaddr, int shmflg);
//连接共享内存到当前进程的地址空间：成功返回指向共享内存的指针，失败返回-1
shmaddr=shmat(shmId,0,0);//挂载映射，如果引用一个已存在的共享内存（上方改革创建），则将 size 指定为0
printf("shmat ok\n");
printf("内容是：%s\n",shmaddr);
//int shmdt(const void *shmaddr);
断开与共享内存的连接
shmdt(shmaddr);
return 0;
}
五、信号
概念：
信号是在软件层次上对中断机制的一种模拟，是一种异步通信方式
信号可以直接进行用户空间进程和内核进程之间的交互，内核进程也可以利用它来通知用户空间进程发生了哪些系统事件。
如果该进程当前并未处于执行态，则该信号就由内核保存起来，直到该进程恢复执行再传递给它；如果一个信号被进程设置为阻塞，则该信号的传递被延迟，直到其阻塞被 取消时才被传递给进程。
用户进程对信号的响应方式：
忽略信号：对信号不做任何处理，但是有两个信号不能忽略：即SIGKILL及SIGSTOP。
捕捉信号：定义信号处理函数，当信号发生时，执行相应的处理函数。
执行缺省操作：Linux对每种信号都规定了默认操作
信号：
SIGINT：ctrl+c 终止信号
SIGQUIT：ctrl+\ 终止信号
SIGTSTP:ctrl+z 暂停信号
SIGALRM：闹钟信号 收到此信号后定时结束，结束进程
SIGCHLD：子进程状态改变，父进程收到信号
SIGKILL：杀死信号
例子
信号绑定
#include <stdio.h>
#include <signal.h>
//typedef void (*sighandler_t)(int);
//sighandler_t signal(int signum, sighandler_t handler);
void handler(int signum)
{
printf("get signum=%d\n",signum);
switch(signum){
case 2:
printf("SIGINT");
break;
case 10:
printf("SIGUSR1");
break;
}
}
int main()
{
signal(SIGINT,handler);//SIGINT是ctrl c的指令
signal(SIGUSR1,handler);//
while(1);
return 0;
}
信号发送（杀死程序的信号 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);
sprintf(cmd,"kill -%d %d",signum,pid);
system(cmd);
printf("发送指令成功\n");
return 0;
}
信号忽略
signal(SIGINT,SIG_IGN)//可以忽略掉ctrl c 的信号
信号如何携带消息
思路
发信号
1.用什么发 sigqueue()
2.怎么放入消息
收信号
1.用什么绑定函数（收到信号如何让处理）sigaction()
int sigaction(int signum, const struct sigaction *act,struct sigaction *oldact(备份原操作));
2.如何读出消息
代码实现
收信号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
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]);
union sigval value;
value.sival_int=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;
}
本打算尝试发送字符串，后来查询发现：发送字符串只能在 共享内存或者 同一进程下 才可以发送
六、信号量
信号量（semaphore）与已经介绍过的 IPC 结构不同，它是一个计数器。信号量用于实现进程间的互斥与同步，而不是用于存储进程间通信数据。
特点
信号量用于进程间同步，若要在进程间传递数据需要结合共享内存。
信号量基于操作系统的 PV 操作，程序对信号量的操作都是原子操作。
每次对信号量的 PV 操作不仅限于对信号量值加 1 或减 1，而且可以加减任意正整数。
支持信号量组。
原型
最简单的信号量是只能取 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>
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.
//int semop(int semid, struct sembuf *sops, size_t nsops); 对信号量组进行操作，改变信号量的值：成功返回0，失败返回-1
semop(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，失败返回-1
semop(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，失败返回-1
semid=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代表操作第一个信号量，
//cmd可以通过man手册差相关的宏，SETVAL设置信号量的初值,设置为initsem,里面有1把琐
int pid = fork();//创建子进程
if(pid > 0){
//去拿锁
pGetKey(semid);//拿锁
printf("这是父进程\n");
vPutBackKey(semid);
//放回锁
semctl(semid,0,IPC_RMID);//销毁锁
}else if(pid == 0){
printf("这是子进程\n");
vPutBackKey(semid);//放索
}else{
printf("创建失败\n");
}
return 0;
}
七、通信方式总结
1.管道：速度慢，容量有限，只有父子进程能通讯
2.FIFO：任何进程间都能通讯，但速度慢
3.消息队列：容量受到系统限制，且要注意第一次读的时候，要考虑上一次没有读完数据的问题
4.信号量：不能传递复杂消息，只能用来同步
5.共享内存区：能够很容易控制容量，速度快，但要保持同步，比如一个进程在写的时候，另一个进程要注意读写的问题，相当于线程中的线程安全，当然，共享内存区同样可以用作线程间通讯，不过没这个必要，线程间本来就已经共享了同一进程内的一块内存
300
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
