一、无名管道
管道，通常指无名管道，是 UNIX 系统IPC最古老的形式。
特点
1、它是半双工的（即数据只能在一个方向上流动），具有固定的读端和写端。
2、它只能用于具有亲缘关系的进程之间的通信（也是父子进程或者兄弟进程之间）。
3、它可以看成是一种特殊的文件，对于它的读写也可以使用普通的read、write 等函数。但是它不是普通的文件，并不属于其他任何文件系统，并且只存在于内存中。
原型：
1 #include <unistd.h>
2 int pipe(int fd[2]); // 返回值：若成功返回0，失败返回-1
实例：
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
int main()
{
int fd[2] = {0};//定义管道标识，f[0]表示读，f[1]表示写
char buf[128] = {0};
pid_t pid = 0;
//int pipe(int pipefd[2]);
if(pipe(fd) == -1){
printf("create pipe failed!\n");
}
pid = fork();
if(pid < 0){
printf("create child failed!\n");
}else if(pid > 0){
sleep(3);
printf("this is father\n");
close(fd[0]);//关闭读端
write(fd[1],"hello,i am father",strlen("hello,i am father"));
close(fd[1]);//关闭写端
wait(NULL);
}else{
printf("this is child\n");
close(fd[1]);//关闭写端
read(fd[0],buf,128);
printf("read from father:%s\n",buf);
close(fd[0]);//关闭写端
exit(0);
}
return 0;
}
二、有名管道FIFO
FIFO，也称为命名管道，它是一种文件类型。
特点
1、IFO可以在无关的进程之间交换数据，与无名管道不同。
2、FIFO有路径名与之相关联，它以一种特殊设备文件形式存在于文件系统中。
原型
1 #include <sys/stat.h>
2 // 返回值：成功返回0，出错返回-1
3 int mkfifo(const char *pathname, mode_t mode);
实例：
writ.c
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
int main()
{
// int mkfifo(const char *pathname, mode_t mode);
char *str = "message from fifo";
int cnt = 0;
if(mkfifo("./file",0600) == -1 && errno != EEXIST){//创建命名管道file
printf("mkfifo failure\n");
perror("why");
}
int fd = open("./file",O_WRONLY);//以只写的方式打开命名管道file
while(1){
write(fd,str,strlen(str));//将str写入管道file
sleep(2);
printf("write success\n");
cnt++;
if(cnt == 5){
break;
}
}
close(fd);//关闭管道
return 0;
}
read.c
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
int main()
{
// int mkfifo(const char *pathname, mode_t mode);
char buf[30] = {0};
int n_read = 0;
if(mkfifo("./file",0600) == -1 && errno != EEXIST){//创建命名管道file
printf("mkfifo failure\n");
perror("why");
}
int fd = open("./file",O_RDONLY);//以只写的方式打开管道file
printf("open success\n");
while(1){
n_read = read(fd,buf,20);//从管道中读出数据放到buf中
sleep(2);
printf("read %d byte,the context is: %s\n",n_read,buf);
}
close(fd);//关闭管道file
return 0;
}
三、消息队列
消息队列，是消息的链接表，存放在内核中。一个消息队列由一个标识符（即队列ID）来标识。
特点
1、消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先级。
2、消息队列独立于发送与接收进程。进程终止时，消息队列及其内容并不会被删除。
3、消息队列可以实现消息的随机查询,消息不一定要以先进先出的次序读取,也可以按消息的类型读取。
原型
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);
实例：
mesGet.c
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
// int msgget(key_t key, int msgflg);
// 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);
// key_t ftok(const char *pathname, int proj_id);
// int msgctl(int msqid, int cmd, struct msqid_ds *buf);
struct msgbuf //用来存消息数据和类型的结构体
{
long mtype; /* message type, must be > 0 */
char mtext[128]; /* message data */
};
int main()
{
struct msgbuf readBuf;
key_t key;
key = ftok(".",'Z');//自动获取key的值，方便后面的msgget使用
printf("key = %x\n",key);
int msgId = msgget(key,IPC_CREAT|0777);//获取、创建一个消息队列 并返回消息队列的标识符
if(msgId == -1){//获取消息队列标识符失败
printf("get queue failure\n");
}
msgrcv(msgId,&readBuf,sizeof(readBuf.mtext),888,0);//接受消息队列中的数据，将其放入readBuf中
printf("receive over\n");
printf("read from queue:%s\n",readBuf.mtext);//将消息打印到标准输出
struct msgbuf sendBuf = {988,"thank you for reach"};//创建发送消息的结构体，方便作为msgsnd的参数，988表示消息类型，后面的字符串表示将要发送的数据
msgsnd(msgId,&sendBuf,strlen(sendBuf.mtext),0);//将消息写入到消息队列中
msgctl(msgId,IPC_RMID,NULL);//销毁消息队列
return 0;
}
mesSend.c
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
// int msgget(key_t key, int msgflg);
// 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);
// int msgctl(int msqid, int cmd, struct msqid_ds *buf);
// key_t ftok(const char *pathname, int proj_id);
struct msgbuf//定义存储消息数据的结构体
{
long mtype; /* message type, must be > 0 */
char mtext[128]; /* message data */
};
int main()
{
struct msgbuf sendBuf = {888,"this message is from queue"}; //初始化将要发送的消息内容
struct msgbuf readBuf;
key_t key;
key = ftok(".",'Z');//自动获取key的值，方便后面使用
printf("key = %x\n",key);
int msgId = msgget(key,IPC_CREAT|0777);//创建、获取消息队列的标识符
if(msgId == -1){
printf("get queue failure\n");
}
msgsnd(msgId,&sendBuf,strlen(sendBuf.mtext),0);//将消息数据写入到消息队列中
printf("send over\n");
msgrcv(msgId,&readBuf,sizeof(readBuf.mtext),988,0);//接收消息
printf("return from get:%s\n",readBuf.mtext);//打印消息内容
msgctl(msgId,IPC_RMID,NULL);//销毁消息队列
return 0;
}
四、共享内存
共享内存（Shared Memory），指两个或多个进程共享一个给定的存储区。
特点
1、共享内存是最快的一种 IPC，因为进程是直接对内存进行存取。
2、因为多个进程可以同时操作，所以需要进行同步。
3、信号量+共享内存通常结合在一起使用，信号量用来同步对共享内存的访问。
原型
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);
实例：
shmW.c
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
// int shmget(key_t key, size_t size, int shmflg);
// void *shmat(int shmid, const void *shmaddr, int shmflg);
// int shmdt(const void *shmaddr);
// int shmctl(int shmid, int cmd, struct shmid_ds *buf);
int main()
{
key_t key;
int shmid;
char *shmaddr = NULL;
key = ftok(".",2);//自动获取key值，方便后面shmget使用
shmid = shmget(key,1024*4,IPC_CREAT|0666);//获取、创建共享内存的标识符shmid
if(shmid == -1){//获取、创建共享内存失败
printf("shmget failure\n");
exit(-1);
}
// exit(0);
shmaddr = shmat(shmid,0,0);//将当前进程连接到刚刚获得的共享内存上，如果成功返回共享内存的地址
printf("shmat ok\n");
strcpy(shmaddr,"xfj handsome");//将要通信的数据写入到共享内存中
sleep(5);
shmdt(shmaddr);//断开当前 与共享内存的连接
shmctl(shmid,IPC_RMID,0);//销毁共享内存
printf("quit\n");
return 0;
}
shmR.c
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
// int shmget(key_t key, size_t size, int shmflg);
// void *shmat(int shmid, const void *shmaddr, int shmflg);
// int shmdt(const void *shmaddr);
// int shmctl(int shmid, int cmd, struct shmid_ds *buf);
int main()
{
key_t key;
int shmid;
char *shmaddr = NULL;//定义一个指针用来接后面连接上共享内存的地址
key = ftok(".",2);//自动获取key值，方便后面 shmget使用
shmid = shmget(key,0,0);//获取、创建共享内存的标识符shmid
if(shmid == -1){//获取、创建共享内存失败
printf("shmget failure\n");
exit(-1);
}
shmaddr = shmat(shmid,0,0);//让当前进程连接到上面获取的共享内存，返回连接上的共享内存的地址
printf("shmat ok\n");
printf("read:%s\n",shmaddr);//打印共享内存中的数据
shmdt(shmaddr);//断开一共享内存的连接
shmctl(shmid,IPC_RMID,0);//销毁共享内存
printf("quit\n");
return 0;
}
五、信号
对于 Linux来说，实际信号是软中断，许多重要的程序都需要处理信号。信号，为 Linux 提供了一种处理异步事件的方法。比如，终端用户输入了 ctrl+c 来中断程序，会通过信号机制停止一个程序。
信号的处理：
信号的处理有三种方法，分别是：忽略、捕捉和默认动作
信号处理函数的注册
信号处理函数的注册不只一种方法，分为入门版和高级版
入门版：函数signal
高级版：函数sigaction
信号处理发送函数
信号发送函数也不止一个，同样分为入门版和高级版
1.入门版：kill
2.高级版：sigqueue
信号注册函数——入门版
#include <signal.h>
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);
实例1
signalDemo.c
#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://捕捉到的信号为SIGINT
printf("SIGINT\n");
break;
case 9://捕捉到的信号为SIGKILL
printf("SIGKILL\n");
break;
case 10://捕捉到的信号为SIGUSR1
printf("SIGUSR1\n");
break;
}
}
int main()
{
signal(SIGINT,SIG_IGN);//忽略信号
signal(SIGKILL,handler);
signal(SIGUSR1,handler);
while(1);
return 0;
}
signalDemoCON.c
#include <stdio.h>
#include <signal.h>
#include <sys/types.h>
#include <stdlib.h>
// int atoi(const char *nptr);
// int kill(pid_t pid, int sig);
// int system(const char *command);
int main(int argc,char *argv[])
{
int signum;
pid_t pid;
char cmd[128] = {0};
signum = atoi(argv[1]);//将输入的字符信号参数转换为int型参数
pid = atoi(argv[2]);//将输入的字符信号参数转换为int型参数
// kill(pid,signum);用kill来发送信号
sprintf(cmd,"kill -%d %d",signum,pid);//用sprintf函数来拼接信号发送命令，并将拼接好的命令存入cmd中
system(cmd);//发送命令
printf("send singal ok\n");
return 0;
}
信号注册函数——高级版
我们已经成功完成了信号的收发，那么为什么会有高级版出现呢？其实之前的信号存在一个问题就是，虽然发送和接收到了信号，可是总感觉少些什么，既然都已经把信号发送过去了，为何不能再携带一些数据呢？
正是如此，我们需要另外的函数来通过信号传递的过程中，携带一些数据。咱么先来看看发送的函数吧。
sigaction 的函数原型
#include <signal.h>
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
struct sigaction {
void (*sa_handler)(int); //信号处理程序，不接受额外数据，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只能任选其一
实例2
highSignalGet.c
#include <stdio.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
// int sigaction(int signum, const struct sigaction *act,struct sigaction *oldact);
/*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)
{
printf("get 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("get from:%d\n",info->si_pid);//打印发送信号的进程的PID
}
}
int main()
{
struct sigaction act;//定义一个捕捉信号后的行为函数
act.sa_sigaction=handler;//当得到对应的信号时执行handler函数
act.sa_flags=SA_SIGINFO;//使信号能够携带数据
printf("pid =%d\n",getpid());//打印当前进程的PID
sigaction(SIGUSR1,&act,NULL);
while(1);
return 0;
}
highSignalSend.c
#include <stdio.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
// int sigqueue(pid_t pid, int sig, const union sigval value);
/* union sigval {
int sival_int;
void *sival_ptr;
};
*/
int main(int argc,char *argv[])
{
pid_t pid;
int signum;
union sigval value;
value.sival_int = 100;//将100作为信号携带的数据赋给共用体value
signum = atoi(argv[1]);//将输入的字符信号参数转换为int型参数
pid = atoi(argv[2]);//将输入的字符信号参数转换为int型参数
sigqueue(pid,signum,value);//发送信号和其携带的数据
printf("pid=%d,send over!\n",getpid());
return 0;
}
六、信号量
信号量（semaphore）与已经介绍过的 IPC 结构不同，它是一个计数器。信号量用于实现进程间的互斥与同步，而不是用于存储进程间通信数据。
特点
1、信号量用于进程间同步，若要在进程间传递数据需要结合共享内存。
2、信号量基于操作系统的 PV 操作，程序对信号量的操作都是原子操作。
3、每次对信号量的 PV 操作不仅限于对信号量值加 1 或减 1，而且可以加减任意正整数。
4、支持信号量组。
最简单的信号量是只能取 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, …);
实例：
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <unistd.h>
// int semget(key_t key, int nsems, int semflg);
// int semctl(int semid, int semnum, int cmd, ...);
// int semop(int semid, struct sembuf *sops, unsigned nsops);
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) */
};
// P处理
// 若信号量值为1，获取资源并将信号量值-1
// 若信号量值为0，进程挂起等待
void pGetKey(int semid)
{
struct sembuf set;
set.sem_num = 0;//信号集中的第0位置的信号量
set.sem_op = -1;//在initem.val上减1
set.sem_flg = SEM_UNDO; //设置为SEM_UNDO，则没有资源时阻塞进程
semop(semid,&set,1);
printf("get key\n");
}
//V处理
// 释放资源并将信号量值+1
// 如果有进程正在挂起等待，则唤醒它们
void vPutBackKey(int semid)
{
struct sembuf set;
set.sem_num = 0;//信号集中的第0位置的信号量
set.sem_op = 1;//在initem.val上加1
set.sem_flg = SEM_UNDO;//设置为SEM_UNDO，则没有资源时阻塞进程
semop(semid,&set,1);
printf("put back key\n");
}
int main()
{
key_t key;
int semid;
key = ftok(".",'Z');//自动获取key值，方便semget使用
union semun initsem;
initsem.val = 0;//初始化资源数，这里0表示，一开始就没有资源
semid = semget(key,1,IPC_CREAT|0666);//获取、创建一个信号量，并返回信号量标识符semid
semctl(semid,0,SETVAL,initsem);//初始化第0个位置的信号量，和数组类似，信号量集的下标从0开始，由于上面
//一共只定义了一个信号量，则我们初始化的就是0位置的信号量
pid_t pid = fork();//创建一个子进程
if(pid == 0){//子进程
printf("fork error!\n");
vPutBackKey(semid);//释放资源
}else if(pid > 0){//父进程
pGetKey(semid);//获取资源
printf("this is father\n");
vPutBackKey(semid);//释放资源
semctl(semid,0,IPC_RMID);//销毁信号量
}else{//创建进程失败
printf("this is child\n");
}
/* fork之后的解释：当子进程被创建之后，我们不知道哪个进程先执行，但一开始我们初始化的资源initsem.val = 0，表示
一开始就没有资源，所以在父进程中一开始就用P处理想要获取资源，但此时没有资源就会导致父进程被挂起，先去执行子进程，
当子进程执行到V处理时，会释放资源，此时父进程就可以得到资源继续执行下去，所以通过信号量的控制，实现了子进程比
父进程先执行*/
return 0;
}
662
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
