进程间的通信（笔记一）

最新推荐文章于 2023-06-25 23:45:00 发布

cubedong

最新推荐文章于 2023-06-25 23:45:00 发布

阅读量124

点赞数 2

本文链接：https://blog.csdn.net/sinat_42550851/article/details/101357626

版权

IPC（进程间的通信）有：无名管道、命名管道、消息队列、共享内存、信号量

无名管道

参考了这篇文章，指路。更加详细
本文链接：https://blog.csdn.net/wh_sjc/article/details/70283843
1、特点：

管道数据，读走就没有了（类似水管）
它是半双工的（即数据只能在一个方向上流动），具有固定的读端和写端。
它只能用于具有亲缘关系的进程之间的通信（也是父子进程或者兄弟进程之间）。
它可以看成是一种特殊的文件，对于它的读写也可以使用普通的read、write 等函数。但是它不是普通的文件，并不属于其他任何文件系统，并且只存在于内存中。

2、原型：

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

3、例子：

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
int main()
{
    //int pipe(int pipefd[2]);//可以利用man pipe找到函数原型
    int pid;
    int fd[2];//两个文件标识符
    char buf[128];
    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]);//关闭读端，读写对应01
        write(fd[1], "hello from father", strlen("hello from father"));
    
        wait();
    }
    else
    {
        printf("this is child\n");
        close(fd[1]);
        read(fd[0], buf, 128);
        printf("read from father\n", buf);
        exit(0);
    }
    return 0;
}

命名管道

FIFO
1、特点：

FIFO可以在无关的进程之间交换数据，与无名管道不同。
只read会阻塞，需要等到某个进程为写而打开FIFO
FIFO，也称为命名管道，它是一种文件类型。FIFO有路径名与之相关联，它以一种特殊设备文件形式存在于文件系统中。

2、原型：

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

3:、例子：

读取文件

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
int main() {
//当文件存在时候不会报错，0600的权限是可读可写，利用manshouce可以查询：man 2 mkfifo
    if (mkfifo("./file", 0600) == -1 && errno != EEXIST) {

        printf("mkfifo failed\n");

        perror("why");

    int fd = open("./file", O_RDONLY);
    printf("open success\n");

    return 0;
}
}

写入文件

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
int main() {

    int cnt = 0;
    char *str = "message from fifo";
    int fd = open("./file", O_WRONLY);
    printf("write open success\n");

    while (1) {
        write(fd, str, strlen(str));

        sleep(1);
        if (cnt == 5) {
            break;
        }
    }
    close(fd);//关闭文件

    return 0;
}

消息队列

首先要讨论两个问题：

如何创建新的消息队列？
B如何加消息队列？
A如何在消息队列中得到消息？

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

1、特点：

消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先级。
消息队列独立于发送与接收进程。进程终止时，消息队列及其内容并不会被删除。
消息队列可以实现消息的随机查询,消息不一定要以先进先出的次序读取,也可以按消息的类型读取。

2、原型：

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。

3、例子：
msgGet

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
struct msgbuf
{
    long mtype;
    char mtext[128];

int main()
{
    struct msgbuf sendBuf={988, "this is from 988"};
    struct msgbuf readBuf;
    int msgId =  msgget(0x1234, IPC_CREAT|0777);

    if(msgId == -1)
    {
        printf("create msgget failed\n");
    }
    msgrcv(msgId, &readBuf, sizeof(readBuf.mtext), 888, 0);

    msgsnd(msgId, &sendBuf, sizeof(sendBuf.mtext), 0);
    printf("read from que:%s\n", readBuf.mtext);
    return 0;
}

msgSend

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
struct msgbuf
{
    long mtype;
    char mtext[128];
};

int main()
{
    struct msgbuf readBuf;
    struct msgbuf sendBuf = {888, "this is message from quen"};
    int msgId =  msgget(0x1234, IPC_CREAT|0777);

    if(msgId == -1)
    {
        printf("create msgget failed\n");
    }

    msgsnd(msgId, &sendBuf, sizeof(sendBuf.mtext), 0);
    msgrcv(msgId, &readBuf, sizeof(readBuf.mtext), 988, 0);
    printf("return from get:%s\n", readBuf.mtext);
    return 0;
}

信号

概述：
两个或多个进程共享一个给定的存储区
kill -l查看信号
有忽略（SIGKILL SIGSTOP不能被忽略）、捕捉、默认动作（比如说ctrl+c是中断）
有一个宏SIGNOT是忽略
思考：

发信号：用什么发？怎么放入消息？
收信号：用什么绑定函数？如何读消息？
3、例子：
入门版本（有人来敲门，但是不说话）

#include <stdio.h>
#include <signal.h>

void handler(int signum)
{
    printf("get signum=%d\n", signum);
    switch(signum)
    {
        case 2:
            printf("SIGINT\n");
            break;
        case 9:
            printf("SIGKILL\n");
            break;
        case 10:
            printf("SIGUSR1\n");
            break;
    }
    printf("never quit");
}
int main()
{
    signal(SIGINT, handler);
    signal(SIGKILL, handler);
    signal(SIGUSR1, handler);
    while(1);
    return 0;
}

#include <stdio.h>
#include <signal.h>
#include <sys/types.h>

int main(int argc, char **argv)
{
    int signum;
    int pid;

    char cmd[128] = {0};
    signum = atoi(argv[1]);
    pid = atoi(argv[2]);

    printf("num=%d,pid=%d\n", signum,pid);
    //kill(pid, signum);
    sprintf(cmd, "kill -%d %d", signum, pid);

    system(cmd);
    printf("send signal ok");


    return 0;
}

```c
#include <stdio.h>
#include <signal.h>
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("from:%d\n", info->si_pid);
    }

}
int main()
{
    struct sigaction act;
    printf("pid=%d\n", getpid());
    act.sa_sigaction = handler;
    act.sa_flags = SA_SIGINFO;//be able to get message

    sigaction(SIGUSR1, &act, NULL);
    while(1);
    return 0;
}

#include <stdio.h>
#include <signal.h>

int main(int arfc, char **argv)
{
    int signum;
    int pid;
    signum = atoi(argv[1]);
    pid = atoi(argv[2]);

    union sigval value;
    value.sival_int = 100;


    sigqueue(pid, signum, value);

    printf("%ddone\n", getpid());
    return 0;

}

共享内存

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

1、特点：

共享内存是最快的一种 IPC，因为进程是直接对内存进行存取。
因为多个进程可以同时操作，所以需要进行同步。
信号量+共享内存通常结合在一起使用，信号量用来同步对共享内存的访问。

2、原型：

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（从系统中删除该共享内存）。

3、例子：
shmw.c

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <string.h>
int main()
{
    int shmid;
    char *shmaddr;

    key_t key;
    key = ftok(".", 1);

    shmid = shmget(key, 1024*4, IPC_CREAT|0666);//开辟空间至少一兆
    if(shmid == -1)
    {
        printf("shmget noOk\n");
        exit(-1);
    }
    shmaddr = shmat(shmid, 0, 0);
    printf("shmat ok\n");
    strcpy(shmaddr, "dlf");

    sleep(5);
    shmdt(shmaddr);

    shmctl(shmid, IPC_RMID, 0);

    printf("quit\n");

    return 0;
}

shmr.c

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <string.h>
int main()
{
    int shmid;
    char *shmaddr;

    key_t key;
    key = ftok(".", 1);

    shmid = shmget(key, 1024*4, 0);
    if(shmid == -1)
    {
        printf("shmget noOk\n");
        exit(-1);
    }
    shmaddr = shmat(shmid, 0, 0);
    printf("shmat ok\n");
    printf("data:%s\n", shmaddr);

    shmdt(shmaddr);


    printf("quit\n");

    return 0;
}

信号量

信号量（semaphore）与已经介绍过的 IPC 结构不同，它是一个计数器。信号量用于实现进程间的互斥与同步，而不是用于存储进程间通信数据。

1、特点：

信号量用于进程间同步，若要在进程间传递数据需要结合共享内存。
信号量基于操作系统的 PV 操作，程序对信号量的操作都是原子操作。
每次对信号量的 PV 操作不仅限于对信号量值加 1 或减 1，而且可以加减任意正整数。
支持信号量组。

2、原型：

最简单的信号量是只能取 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, ...);

当semget创建新的信号量集合时，必须指定集合中信号量的个数（即num_sems），通常为1；如果是引用一个现有的集合，则将num_sems指定为 0 。

3、例子：

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

union semun
{
    int val;
    struct semid_ds *buf;
    unsigned *array;
    struct seminfo *__buf;
};
void pGetKey(int id)
{
    struct sembuf set;
    set.sem_num = 0;
    set.sem_op = -1;
    set.sem_flg = SEM_UNDO;

    semop(id, &set, 1);
    printf("getkey\n");


}
void vPutBackKey(int id)
{
    struct sembuf set;
    set.sem_num = 0;
    set.sem_op = 1;
    set.sem_flg = SEM_UNDO;

    semop(id, &set, 1);
    printf("put back the key\n");
}
int main(int argc, char const *argv[])
{
    key_t key;
     int semid;

    key = ftok(".", 2);

    semid = semget(key, 1,IPC_CREAT|0666);

    union semun initsem;
    initsem.val = 0;
    semctl(semid, 0, SETVAL, initsem);

int pid = fork();
if(pid > 0)
{
    pGetKey(semid);
    printf("this is father\n");

    vPutBackKey(semid);
    semctl(semid, 0, IPC_RMID);


}
else if(pid == 0)
{

    printf("this is child\n");

    vPutBackKey(semid);
}
else
{
    printf("error");
}
return 0;   
}