linux的进程间通信:
一、半双工的管道:
1、半双工unix管道:
pipe(fd)
进程创建管道时,内核创建两个文件描述符。一个用于写,另一个用于读。创建管道的进程只能用该管道与自己通信。
而父进程创建子进程后,子进程会继承父进程的文件描述符,也就可以进行和父进程通信了。(限于父子进程的通信,而且管道通信直接与内核打交道)
举例:
#include<iostream>
#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
using namespace std;
int main()
{
int fd[2];
pipe(fd); //必须在fork()之前,否则子进程没法继承父进程的文件描述符
pid_t pid;
pid = fork();
if(pid == -1)
cout<<"fork ocur error"<<endl;
if(0 == pid)
{
char str[] = "child connect parent process";
cout<<"This is child process"<<endl;
close(fd[0]);//关闭fd[0]
write(fd[1],str,strlen(str));
exit(0);
}
else
{
char rstr[1024];
memset(rstr,0,1024);
cout<<"This is parent process"<<endl;
close(fd[1]);
read(fd[0],rstr,strlen(rstr));
cout<<rstr<<endl;
}
return 0;
}
2、使用简便的高级管道:
FILE *fp = popen("str","r/w")
说明:使用popen直接使用管道打开另一个进程,可以直接使用shell命令。
参数:第一个是执行的操作命令字符创,第二个是操作的流类型(如果是r,返回的是stdin流类型,w返回的是stdout流类型)
举例:
#include<stdio.h>
#include<string>
int main()
{
string str = "ps -ef |grep -w `whoami`";
char outbuf[1024];
memset(outbuf,0,1024);
FILE* fstdin =NULL;
if(fstdin = popen(str.c_str,"r") == -1);
{
perror("popen ocurs error");
exit(1);
}
else
{
while(fgets(outbuf,1024,fstdin))
{
if(strncmp(outbuf,"oraname",sizeof("oraname"))==0)
{
printf("The value eque :%s",outbuf);
break;
}
}
pclose(fstdin);
exit(0);
}
return 0;
}
3、管道的原子操作
管道的原子操作的最大缓存是有限制的,linux的配置在 linux/limits.h中的
#define PIPE_BUF 4096
二、命名管道:
1、命名管道与半双工管道的区别:
在文件系统中命名管道时以设备特殊文件的形式存在的(半双工是内核直接调用的)
在不同家族的进程可以通过命名管道共享数据(也就是不仅仅父子进程)
mknod MYFIFO p
或者
mkfifo a=rw MYFIFO
在c语言中使用:mknod("/tmp/MYFIFO",S_IFIFO|0666,0);
举例:
创建命名管道,然后阻塞读取管道文件的内容
服务端进程:
#include<stdio.h>
#include<stdlib.h>
#include<sys/stat.h>
#include<unistd.h>
#include<linux/stat.h>
#define FIFO_FILE "MYFIFO"
int main()
{
FILE* fp =NULL;
char readbuf[256];
memset(readbuf,0,256);
umask(0);
mknod(FIFO_FILE,S_IFIFO|0666,0);
while(1)
{
fp = fopen(FIFO_FILE,"r");
if(fp ==NULL)
{
perror("fopen ocurs error");
fclose(fp);
exit(1);
}
fgets(readbuf,256,fp);
printf("service readbuf is: %s",readbuf);
fclose(fp);
}
return 0;
}
客户端进程:
#include<stdio.h>
#include<stdlib.h>
#define FIFO_FILE "MYFIFO"
int main(int argc,char* argv[])
{
FILE* fd = NULL;
//char writebuf[256];
//memset(writebuf,0,256);
fd = fopen(FIFO_FILE,"w");
if(fd == NULL)
{
perror("open file ocurs error");
exit(1);
}
fputs(argv[1],fd);
fclose(fd);
return 0;
}
三、消息队列:内核地址空间中的内部链表
1、使用IPC标识符,此标识符在消息队列中是独一无二的,这样通过标识符就可以确定访问
2、使用关键字key_t,可以获取IPC标识符。
(ipcs命令可以显示当前所有的IPC信息,ipcrm删除一个IPC信息)
一般使用步骤:
a、获取可用的关键字
key_t key = ftok();
(也可以不使用这个函数,我们自己定义一个消息类型,然后由msgget检查并创建)
b、获取关键字对应的msgid(标识符)
int msgget(key_t key,int msgflag)
其中的msgflag主要参数:IPC_CREAT、IPC_EXECL
失败返回-1
如:
int msgid = msgget(key,IPC_CREAT|0660)
c、向消息队列中发送消息,这样内存中就有发送的数据了(一般是发送的进程)
int msgsnd(int msgid,struct msgbuf* msg,int msgsz,int msgflag)
其中struct msgbuf结构体是我们重载的消息结构体
msgflag表示是否需要阻塞(0表示忽略,IPC_NOWAIT表示立即中断,直到可以写消息)
如:
msgsnd(msgid,mymsgbuf,sizeof(mymsgbuf),0)
d、从消息队列中获取消息(一般是接收的进程)
int msgrcv(int msgid,struct msgbuf* msg,int msgsize,long mtype,int msgflag)
常见的几个重要的msg的struct:
a.消息的内存结构,用户自己可定义buf
struct msgbuf
{
long mtype;
char msg_text[1];
};
b.消息内核处理的基本结构(类似于一个节点):
struct msg
{
struct msg* msg_next;
long msg_type;
char* msg_spot; //消息体的指针头
short msg_ts; //消息体的大小
};
c.msgid_ds结构体,存放消息处理过程的数据(使用msgctl(int msgid,int cmd(IPC_STAT/IPC_SET/IPC_RMID),struct msgid_ds* buf)来获取,修改,删除等操作)
struct msgid_ds
{
struct ipc_perm msg_perm;
struct msg* msg_first;
struct msg* msg_last;
time_t msg_stime;
time_t msg_rtime;
time_t msg_ctime;
****
};
d.ipc_perm结构体,描述内核ipc对象的许可信息。
struct ipc_perm
{
key_t key;
ushort uid;
ushort gid;
ushort cuid;
ushort cgid;
ushort mode;
ushort seq;
};
举例:
发送端:
#include<stdio.h>
#include<stdlib.h>
#include<sys/msg.h>
#include<ctype.h>
#include<sys/types.h>
#include<sys/ipc.h>
#define 80
#define MSGKEY 1024
struct mymsgbuf
{
long mtype;
char mtext[MAX_SEND_SIZE];
};
int main()
{
key_t key;
int msgid;
long msgtype;
char msgtext[MAX_SEND_SIZE];
struct mymsgbuf msgbuf;
/*
msgbuf.mtype = 0;
strcpy(msgbuf.mtext,"simple txt");
*/
//key = ftok(".",'m');
msgid = msgget(MSGKEY,IPC_EXECL);
if(msgid < 0)
{
msgid = msgget(MSGKEY,IPC_CREAT|0660);
if(msgid <0)
{
perror("msgget ocurs error");
exit(1);
}
}
while(1)
{
printf("input message type:");
scanf("%d",&msgtype);
if(msgtype = 0)
break;
printf("input message text:");
scanf("%s",msgtext);
msgbuf.mtype = msgtype;
strcpy(msgbuf.mtext,msgtext);
msgsnd(msgid,&msgbuf,sizeof(msgbuf)-sizeof(long),IPC_NOWAIT);
}
msgctl(msgid,IPC_RMID,0);
return 0;
}
接收端:
#include<stdio.h>
#include<stdlib.h>
#include<sys/msg.h>
#include<ctype.h>
#include<sys/types.h>
#include<sys/ipc.h>
#define MAX_RECV_SIZE 80
#define MSGKEY 1024
struct mymsgbuf
{
long mtype;
char msgtext[MAX_RECV_SIZE];
};
int main()
{
int msgid;
struct mymsgbuf recvbuf;
int size = sizeof(recvbuf) - sizeof(long);
msgid = msgget(MSGKEY,IPC_EXECL);
if(msgid <0)
{
msgid = msgget(MSGKEY,IPC_CREAT|0660);
if(msgid <0)
{
perror("client create msg occurs error");
exit(1);
}
}
msgrcv(msgid,&recvbuf,size,0);
printf("msg text is :%s",recvbuf.msgtext);
return 0;
}
四、信号量:它是一种计数器,用来控制对多个进程共享的资源所进行的访问
编程的步骤与消息队列几乎一致,需要和消息队列进程区别:消息队列是内核的一个链表序列结构,我们将需要发送和接受内核链表的消息,来进行IPC通信。
而信号量是在共享的资源进行控制。
1、步骤:
获取信号量的标识符
int semget(key_t key,int nsems,int semflag) ---很好理解:第一个key值,表示哪个信息量,第二个是信号量集合的大小(相当于几个打印机),第三个获取信号量的方式(IPC_CREAT/IPC_EXCL)
当我们使用IPC_EXCL判断某个信号量是否存在时,那么信号量的大小就没有意义了。
初始化信号量的buf内容
union semun sem_union;
sem_union.val = 0; //初始化信号量的值为0
int semctl(int sem_id,0,SETVAL,sem_union)
进行信号量处理:
struct sembuf sem_b;
sem_b.sem_num =0;
sem_b.sem_op = -1;
sem_b.sem_flg =SEM_UNDO;
int semop(int sem_id,&sem_b,1);
释放信号量:
semctl(sem_id,0,IPC_RMID,sem_union)
实例:
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/sem.h>
#include<sys/ipc.h>
#include<unistd.h>
#define DELAY_TIME 3
union semun
{
int val;
struct semid_ds* buf;
unsigned short* array;
};
int init_sem(int sem_id,int init_value);
int del_sem(int sem_id);
int sem_p(int sem_id);
int sem_v(int sem_id);
int main()
{
pid_t result;
int sem_id;
sem_id = semget(ftok(".",'a'),1,0666|IPC_CREAT);
init_sem(sem_id,0);
result = fork();
if(result == -1)
{
perror("fork occurs error\n");
}
else if(result == 0)
{
printf("child process will exec....\n");
sleep(DELAY_TIME);
sem_v(sem_id);
}
else
{
printf("parent process will exec...\n");
sem_p(sem_id);
printf("parent process exec");
sem_v(sem_id);
del_sem(sem_id);
}
exit(0);
}
int init_sem(int sem_id,int init_value)
{
union semun sem_union;
sem_union.val = init_value;
if(semctl(sem_id,0,SETVAL,sem_union))
{
perror("Initialize semaphore");
return -1;
}
return 0;
}
int del_sem(int sem_id)
{
union semun sem_union;
if(semctl(sem_id,0,IPC_RMID,sem_union) == -1)
{
perror("Delete Semaphore");
return -1;
}
return 0;
}
int sem_p(int sem_id)
{
struct sembuf sem_b;
sem_b.sem_num = 0;
sem_b.sem_op = -1;
sem_b.sem_flg = SEM_UNDO;
if(semop(sem_id,&sem_b,1) == -1)//对一个信号量进程-1操作
{
perror("p operation");
return -1;
}
return 0;
}
int sem_v(int sem_id)
{
struct sembuf sem_b;
sem_b.sem_num =0;
sem_b.sem_op = 1;
sem_b.sem_flg = SEM_UNDO;
if(semop(sem_id,&sem_b,1) == -1)
{
perror("V operation");
return -1;
}
return 0;
}
五、共享内存
1、概念:内存映射的共享区域,是最快的IPC方式,映射的内存段可以被某个进程创建,其他进程可以随意读随意写,但是在写时最好是用信号量的方式进行锁住,防止交叉感染。
2、简单的几个内存结构:
struct shmid_ds
{
struct ipc_perm shm_perm;
int shm_segsz;
time_t shm_atime;
time_t shm_dtime;
time_t shm_ctime;
unsigned short shm_cpid;//create pid
unsigned short shm_lpid;//pid of last operator
****
}
这个结构体的重要性不用说了,如何获取或者设置对应的值呢?和前面一样也是通过shmctl()函数进行处理
这个结构体也就不说了,基本都是共享内存的许可信息
struct ipc_perm
{
}
int shmctl(int shmid,int cmd,struct shmid_ds* buf);
使用的方法:
IPC_STAT 获取buf的信息
IPC_SET 设置shmid_ds结构体的ipc_perm的成员值
IPC_RMID 标记shmid用于删除,此时不会删除,需要调用shmdt(char* shmaddr)来删除。
相对于前面的几种,共享内存其实是最方便的一个,仅仅在没有进程竞争读写修改时最好。
3、举例:
创建共享内存的进程:
#include<stdlib.h>
#include<stdio.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<unistd.h>
#define MAX_SHM_SZIE 1024
#define SHM_KEY 888
int main()
{
int shm_id;
char* shmadd = NULL;
char shmstr[64] = "sbdcsb";
//key_t key;
//key = ftok(".",'m');
if(shm_id = shmget(SHM_KEY,MAX_SHM_SZIE,IPC_CREAT|0660|IPC_EXCL) < 0)
{
if(shm_id = shmget(SHM_KEY,MAX_SHM_SZIE,0))
{
perror("shmget occours error");
exit(1);
}
}
shmadd = shmat(shm_id,0,0);//挂接地址系统自己选取,方式默认
if(shmadd == NULL)
{
perror("shmat occours error");
exit(1);
}
//没有进行共享内存的删除,因为其他进程需要使用
//可以通过判断shm的内存数据来判断是否需要删除,
//比如内存的第一个字符表示是否删除标识
shmadd[0] = 'N';//初始化不删除,后面其他进程可以设置是否删除
strcpy(shmadd+1,shmstr);//进行内存赋值操作
while(1)
{
if(shmadd[0] == 'Y')
{
shmctl(shm_id,RMID,0)
shmdt(shmadd);
break;
}
}
return 0;
}
使用共享内存的进程:
#include<stdlib.h>
#include<stdio.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<unistd.h>
#define MAX_SHM_SZIE 1024
#define SHM_KEY 888
int main()
{
int shm_id;
char* shmadd = NULL;
char shmstr[64] = "sbdcsb";
//key_t key;
//key = ftok(".",'m');
if(shm_id = shmget(SHM_KEY,0,IPC_EXCL) < 0)
{
perror("shmget occurs error");
exit(1);
}
shmadd = shmat(shm_id,0,0);//挂接地址系统自己选取,方式默认
if(shmadd == NULL)
{
perror("shmat occours error");
exit(1);
}
//没有进行共享内存的删除,因为其他进程需要使用
//可以通过判断shm的内存数据来判断是否需要删除,
//比如内存的第一个字符表示是否删除标识
printf("shm content is :%s",shmadd+1);
//将内存头设置为Y
sleep(1);
shmadd[0] = 'Y';
return 0;
}
一、半双工的管道:
1、半双工unix管道:
pipe(fd)
进程创建管道时,内核创建两个文件描述符。一个用于写,另一个用于读。创建管道的进程只能用该管道与自己通信。
而父进程创建子进程后,子进程会继承父进程的文件描述符,也就可以进行和父进程通信了。(限于父子进程的通信,而且管道通信直接与内核打交道)
举例:
#include<iostream>
#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
using namespace std;
int main()
{
int fd[2];
pipe(fd); //必须在fork()之前,否则子进程没法继承父进程的文件描述符
pid_t pid;
pid = fork();
if(pid == -1)
cout<<"fork ocur error"<<endl;
if(0 == pid)
{
char str[] = "child connect parent process";
cout<<"This is child process"<<endl;
close(fd[0]);//关闭fd[0]
write(fd[1],str,strlen(str));
exit(0);
}
else
{
char rstr[1024];
memset(rstr,0,1024);
cout<<"This is parent process"<<endl;
close(fd[1]);
read(fd[0],rstr,strlen(rstr));
cout<<rstr<<endl;
}
return 0;
}
2、使用简便的高级管道:
FILE *fp = popen("str","r/w")
说明:使用popen直接使用管道打开另一个进程,可以直接使用shell命令。
参数:第一个是执行的操作命令字符创,第二个是操作的流类型(如果是r,返回的是stdin流类型,w返回的是stdout流类型)
举例:
#include<stdio.h>
#include<string>
int main()
{
string str = "ps -ef |grep -w `whoami`";
char outbuf[1024];
memset(outbuf,0,1024);
FILE* fstdin =NULL;
if(fstdin = popen(str.c_str,"r") == -1);
{
perror("popen ocurs error");
exit(1);
}
else
{
while(fgets(outbuf,1024,fstdin))
{
if(strncmp(outbuf,"oraname",sizeof("oraname"))==0)
{
printf("The value eque :%s",outbuf);
break;
}
}
pclose(fstdin);
exit(0);
}
return 0;
}
3、管道的原子操作
管道的原子操作的最大缓存是有限制的,linux的配置在 linux/limits.h中的
#define PIPE_BUF 4096
二、命名管道:
1、命名管道与半双工管道的区别:
在文件系统中命名管道时以设备特殊文件的形式存在的(半双工是内核直接调用的)
在不同家族的进程可以通过命名管道共享数据(也就是不仅仅父子进程)
mknod MYFIFO p
或者
mkfifo a=rw MYFIFO
在c语言中使用:mknod("/tmp/MYFIFO",S_IFIFO|0666,0);
举例:
创建命名管道,然后阻塞读取管道文件的内容
服务端进程:
#include<stdio.h>
#include<stdlib.h>
#include<sys/stat.h>
#include<unistd.h>
#include<linux/stat.h>
#define FIFO_FILE "MYFIFO"
int main()
{
FILE* fp =NULL;
char readbuf[256];
memset(readbuf,0,256);
umask(0);
mknod(FIFO_FILE,S_IFIFO|0666,0);
while(1)
{
fp = fopen(FIFO_FILE,"r");
if(fp ==NULL)
{
perror("fopen ocurs error");
fclose(fp);
exit(1);
}
fgets(readbuf,256,fp);
printf("service readbuf is: %s",readbuf);
fclose(fp);
}
return 0;
}
客户端进程:
#include<stdio.h>
#include<stdlib.h>
#define FIFO_FILE "MYFIFO"
int main(int argc,char* argv[])
{
FILE* fd = NULL;
//char writebuf[256];
//memset(writebuf,0,256);
fd = fopen(FIFO_FILE,"w");
if(fd == NULL)
{
perror("open file ocurs error");
exit(1);
}
fputs(argv[1],fd);
fclose(fd);
return 0;
}
三、消息队列:内核地址空间中的内部链表
1、使用IPC标识符,此标识符在消息队列中是独一无二的,这样通过标识符就可以确定访问
2、使用关键字key_t,可以获取IPC标识符。
(ipcs命令可以显示当前所有的IPC信息,ipcrm删除一个IPC信息)
一般使用步骤:
a、获取可用的关键字
key_t key = ftok();
(也可以不使用这个函数,我们自己定义一个消息类型,然后由msgget检查并创建)
b、获取关键字对应的msgid(标识符)
int msgget(key_t key,int msgflag)
其中的msgflag主要参数:IPC_CREAT、IPC_EXECL
失败返回-1
如:
int msgid = msgget(key,IPC_CREAT|0660)
c、向消息队列中发送消息,这样内存中就有发送的数据了(一般是发送的进程)
int msgsnd(int msgid,struct msgbuf* msg,int msgsz,int msgflag)
其中struct msgbuf结构体是我们重载的消息结构体
msgflag表示是否需要阻塞(0表示忽略,IPC_NOWAIT表示立即中断,直到可以写消息)
如:
msgsnd(msgid,mymsgbuf,sizeof(mymsgbuf),0)
d、从消息队列中获取消息(一般是接收的进程)
int msgrcv(int msgid,struct msgbuf* msg,int msgsize,long mtype,int msgflag)
常见的几个重要的msg的struct:
a.消息的内存结构,用户自己可定义buf
struct msgbuf
{
long mtype;
char msg_text[1];
};
b.消息内核处理的基本结构(类似于一个节点):
struct msg
{
struct msg* msg_next;
long msg_type;
char* msg_spot; //消息体的指针头
short msg_ts; //消息体的大小
};
c.msgid_ds结构体,存放消息处理过程的数据(使用msgctl(int msgid,int cmd(IPC_STAT/IPC_SET/IPC_RMID),struct msgid_ds* buf)来获取,修改,删除等操作)
struct msgid_ds
{
struct ipc_perm msg_perm;
struct msg* msg_first;
struct msg* msg_last;
time_t msg_stime;
time_t msg_rtime;
time_t msg_ctime;
****
};
d.ipc_perm结构体,描述内核ipc对象的许可信息。
struct ipc_perm
{
key_t key;
ushort uid;
ushort gid;
ushort cuid;
ushort cgid;
ushort mode;
ushort seq;
};
举例:
发送端:
#include<stdio.h>
#include<stdlib.h>
#include<sys/msg.h>
#include<ctype.h>
#include<sys/types.h>
#include<sys/ipc.h>
#define 80
#define MSGKEY 1024
struct mymsgbuf
{
long mtype;
char mtext[MAX_SEND_SIZE];
};
int main()
{
key_t key;
int msgid;
long msgtype;
char msgtext[MAX_SEND_SIZE];
struct mymsgbuf msgbuf;
/*
msgbuf.mtype = 0;
strcpy(msgbuf.mtext,"simple txt");
*/
//key = ftok(".",'m');
msgid = msgget(MSGKEY,IPC_EXECL);
if(msgid < 0)
{
msgid = msgget(MSGKEY,IPC_CREAT|0660);
if(msgid <0)
{
perror("msgget ocurs error");
exit(1);
}
}
while(1)
{
printf("input message type:");
scanf("%d",&msgtype);
if(msgtype = 0)
break;
printf("input message text:");
scanf("%s",msgtext);
msgbuf.mtype = msgtype;
strcpy(msgbuf.mtext,msgtext);
msgsnd(msgid,&msgbuf,sizeof(msgbuf)-sizeof(long),IPC_NOWAIT);
}
msgctl(msgid,IPC_RMID,0);
return 0;
}
接收端:
#include<stdio.h>
#include<stdlib.h>
#include<sys/msg.h>
#include<ctype.h>
#include<sys/types.h>
#include<sys/ipc.h>
#define MAX_RECV_SIZE 80
#define MSGKEY 1024
struct mymsgbuf
{
long mtype;
char msgtext[MAX_RECV_SIZE];
};
int main()
{
int msgid;
struct mymsgbuf recvbuf;
int size = sizeof(recvbuf) - sizeof(long);
msgid = msgget(MSGKEY,IPC_EXECL);
if(msgid <0)
{
msgid = msgget(MSGKEY,IPC_CREAT|0660);
if(msgid <0)
{
perror("client create msg occurs error");
exit(1);
}
}
msgrcv(msgid,&recvbuf,size,0);
printf("msg text is :%s",recvbuf.msgtext);
return 0;
}
四、信号量:它是一种计数器,用来控制对多个进程共享的资源所进行的访问
编程的步骤与消息队列几乎一致,需要和消息队列进程区别:消息队列是内核的一个链表序列结构,我们将需要发送和接受内核链表的消息,来进行IPC通信。
而信号量是在共享的资源进行控制。
1、步骤:
获取信号量的标识符
int semget(key_t key,int nsems,int semflag) ---很好理解:第一个key值,表示哪个信息量,第二个是信号量集合的大小(相当于几个打印机),第三个获取信号量的方式(IPC_CREAT/IPC_EXCL)
当我们使用IPC_EXCL判断某个信号量是否存在时,那么信号量的大小就没有意义了。
初始化信号量的buf内容
union semun sem_union;
sem_union.val = 0; //初始化信号量的值为0
int semctl(int sem_id,0,SETVAL,sem_union)
进行信号量处理:
struct sembuf sem_b;
sem_b.sem_num =0;
sem_b.sem_op = -1;
sem_b.sem_flg =SEM_UNDO;
int semop(int sem_id,&sem_b,1);
释放信号量:
semctl(sem_id,0,IPC_RMID,sem_union)
实例:
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/sem.h>
#include<sys/ipc.h>
#include<unistd.h>
#define DELAY_TIME 3
union semun
{
int val;
struct semid_ds* buf;
unsigned short* array;
};
int init_sem(int sem_id,int init_value);
int del_sem(int sem_id);
int sem_p(int sem_id);
int sem_v(int sem_id);
int main()
{
pid_t result;
int sem_id;
sem_id = semget(ftok(".",'a'),1,0666|IPC_CREAT);
init_sem(sem_id,0);
result = fork();
if(result == -1)
{
perror("fork occurs error\n");
}
else if(result == 0)
{
printf("child process will exec....\n");
sleep(DELAY_TIME);
sem_v(sem_id);
}
else
{
printf("parent process will exec...\n");
sem_p(sem_id);
printf("parent process exec");
sem_v(sem_id);
del_sem(sem_id);
}
exit(0);
}
int init_sem(int sem_id,int init_value)
{
union semun sem_union;
sem_union.val = init_value;
if(semctl(sem_id,0,SETVAL,sem_union))
{
perror("Initialize semaphore");
return -1;
}
return 0;
}
int del_sem(int sem_id)
{
union semun sem_union;
if(semctl(sem_id,0,IPC_RMID,sem_union) == -1)
{
perror("Delete Semaphore");
return -1;
}
return 0;
}
int sem_p(int sem_id)
{
struct sembuf sem_b;
sem_b.sem_num = 0;
sem_b.sem_op = -1;
sem_b.sem_flg = SEM_UNDO;
if(semop(sem_id,&sem_b,1) == -1)//对一个信号量进程-1操作
{
perror("p operation");
return -1;
}
return 0;
}
int sem_v(int sem_id)
{
struct sembuf sem_b;
sem_b.sem_num =0;
sem_b.sem_op = 1;
sem_b.sem_flg = SEM_UNDO;
if(semop(sem_id,&sem_b,1) == -1)
{
perror("V operation");
return -1;
}
return 0;
}
五、共享内存
1、概念:内存映射的共享区域,是最快的IPC方式,映射的内存段可以被某个进程创建,其他进程可以随意读随意写,但是在写时最好是用信号量的方式进行锁住,防止交叉感染。
2、简单的几个内存结构:
struct shmid_ds
{
struct ipc_perm shm_perm;
int shm_segsz;
time_t shm_atime;
time_t shm_dtime;
time_t shm_ctime;
unsigned short shm_cpid;//create pid
unsigned short shm_lpid;//pid of last operator
****
}
这个结构体的重要性不用说了,如何获取或者设置对应的值呢?和前面一样也是通过shmctl()函数进行处理
这个结构体也就不说了,基本都是共享内存的许可信息
struct ipc_perm
{
}
int shmctl(int shmid,int cmd,struct shmid_ds* buf);
使用的方法:
IPC_STAT 获取buf的信息
IPC_SET 设置shmid_ds结构体的ipc_perm的成员值
IPC_RMID 标记shmid用于删除,此时不会删除,需要调用shmdt(char* shmaddr)来删除。
相对于前面的几种,共享内存其实是最方便的一个,仅仅在没有进程竞争读写修改时最好。
3、举例:
创建共享内存的进程:
#include<stdlib.h>
#include<stdio.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<unistd.h>
#define MAX_SHM_SZIE 1024
#define SHM_KEY 888
int main()
{
int shm_id;
char* shmadd = NULL;
char shmstr[64] = "sbdcsb";
//key_t key;
//key = ftok(".",'m');
if(shm_id = shmget(SHM_KEY,MAX_SHM_SZIE,IPC_CREAT|0660|IPC_EXCL) < 0)
{
if(shm_id = shmget(SHM_KEY,MAX_SHM_SZIE,0))
{
perror("shmget occours error");
exit(1);
}
}
shmadd = shmat(shm_id,0,0);//挂接地址系统自己选取,方式默认
if(shmadd == NULL)
{
perror("shmat occours error");
exit(1);
}
//没有进行共享内存的删除,因为其他进程需要使用
//可以通过判断shm的内存数据来判断是否需要删除,
//比如内存的第一个字符表示是否删除标识
shmadd[0] = 'N';//初始化不删除,后面其他进程可以设置是否删除
strcpy(shmadd+1,shmstr);//进行内存赋值操作
while(1)
{
if(shmadd[0] == 'Y')
{
shmctl(shm_id,RMID,0)
shmdt(shmadd);
break;
}
}
return 0;
}
使用共享内存的进程:
#include<stdlib.h>
#include<stdio.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<unistd.h>
#define MAX_SHM_SZIE 1024
#define SHM_KEY 888
int main()
{
int shm_id;
char* shmadd = NULL;
char shmstr[64] = "sbdcsb";
//key_t key;
//key = ftok(".",'m');
if(shm_id = shmget(SHM_KEY,0,IPC_EXCL) < 0)
{
perror("shmget occurs error");
exit(1);
}
shmadd = shmat(shm_id,0,0);//挂接地址系统自己选取,方式默认
if(shmadd == NULL)
{
perror("shmat occours error");
exit(1);
}
//没有进行共享内存的删除,因为其他进程需要使用
//可以通过判断shm的内存数据来判断是否需要删除,
//比如内存的第一个字符表示是否删除标识
printf("shm content is :%s",shmadd+1);
//将内存头设置为Y
sleep(1);
shmadd[0] = 'Y';
return 0;
}