参考: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.共享内存区:能够很容易控制容量,速度快,但要保持同步,比如一个进程在写的时候,另一个进程要注意读写的问题,相当于线程中的线程安全,当然,共享内存区同样可以用作线程间通讯,不过没这个必要,线程间本来就已经共享了同一进程内的一块内存