Linux进程间通信demo.c

已于 2024-01-08 10:03:49 修改
阅读量64 收藏
点赞数
分类专栏： linux c/c++ 文章标签： linux c语言
于 2021-07-06 16:51:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37829435/article/details/115446528
版权
c/c++ 同时被 2 个专栏收录
20 篇文章 0 订阅
订阅专栏
linux
6 篇文章 0 订阅
订阅专栏

1.错误处理函数：

#include<stdio.h>
#include<errno.h>
#include<string.h>

int main(void)
{
    FILE *Fr = fopen("./2.txt", "r");
    //全局变量errno会实时更新，装载的是最新被调用的系统回调的操作状态
    //如下面操作，如果2.txt打开成功，errno装载的值表示的是success,否则其
    //装载的值表示的是failed
    if(NULL == Fr)
    {
        printf("1.errno:%d\n",errno);
        printf("1.errno:%s\n",strerror(errno));
        perror("1.fopen error");
    }
    else
    {
        printf("2.errno:%d\n",errno);
        printf("2.errno:%s\n",strerror(errno));
        perror("2.fopen error");
    }
    return 0;
}

2.进程的创建：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>

int main(void)
{
    int i = 0;
    pid_t pid = -1;
    int ret = -1;
    //连续创建3个子进程
    for(i=0; i<3; i++)
    {
        pid = fork();
        if(-1 == pid)
        {
            perror("fork");
            break;
        }
        //fork成功，子进程中返回0；父进程中返回子进程ID
        if(0 == pid)
        {
            break;
        }
    }

    if(0 == i)
    {
        printf("第1个子进程 getpid:%d\n", getpid());
    }
    else if(1 == i)
    {
        printf("第2个子进程 getpid:%d\n", getpid());
    }
    else if(2 == i)
    {
        printf("第3个子进程 getpid:%d\n", getpid());
    }
    else
    {
        //父进程  阻塞 等全部子进程结束，将回收其资源并结束阻塞
        while(-1 != (ret = waitpid(-1, NULL, 0)))
        {
            printf("父进程等待子进程pid:%d\n", ret);
        }
    }

    return 0;
}

3.无名管道

（1）无名管道用于父子进程或者兄弟进程间通信；

（2）系统中使用ulimit -a;命令可以查看管道对应的缓冲区大小；

使用管道需要注意以下4种特殊情况（假设都是阻塞I/O操作，没有设置O_NONBLOCK标志）：
(1)如果所有指向管道写端的文件描述符都关闭了（管道写端引用计数为0），而仍然有进程从管道的读端读数据，那么管道中剩余的数据都被读取后，再次read会返回0，就像读到文件末尾一样。
(2)如果有指向管道写端的文件描述符没关闭（管道写端引用计数大于0），而持有管道写端的进程也没有向管道中写数据，这时有进程从管道读端读数据，那么管道中剩余的数据都被读取后，再次read会阻塞，直到管道中有数据可读了才读取数据并返回。
(3)如果所有指向管道读端的文件描述符都关闭了（管道读端引用计数为0），这时有进程向管道的写端write，那么该进程会收到信号SIGPIPE，通常会导致进程异常终止。当然也可以对SIGPIPE信号实施捕捉，不终止进程。具体方法信号章节详细介绍。
(4)如果有指向管道读端的文件描述符没关闭（管道读端引用计数大于0），而持有管道读端的进程也没有从管道中读数据，这时有进程向管道写端写数据，那么在管道被写满时再次write会阻塞，直到管道中有空位置了才写入数据并返回。

总结：
读管道：    
管道中有数据，read返回实际读到的字节数。
管道中无数据：
管道写端被全部关闭，read返回0 (相当于读到文件结尾)
写端没有全部被关闭，read阻塞等待(不久的将来可能有数据递达，此时会让出cpu)

写管道：
管道读端全部被关闭， 进程异常终止(也可使用捕捉SIGPIPE信号，使进程不终止)
管道读端没有全部关闭： 
管道已满，write阻塞。
管道未满，write将数据写入，并返回实际写入的字节数。

3-1.无名管道的创建：

#include<stdio.h>
#include<unistd.h>
int main(void)
{
    int ret = -1;
    int fd[2] = {0};

    //创建一个无名管道，fd[0]用于读，fd[1]用于写
    ret = pipe(fd);
    if(-1 == ret)
    {
        perror("pipe");
        goto err0;
    }

    //返回两个最小的待使用文件描述符供使用
    printf("fd[0]: %d  fd[1]: %d\n", fd[0], fd[1]);

    //关闭文件描述符
    close(fd[0]);
    close(fd[1]);

    return 0;
err0:
    return 1;
    return 0;
}

3-2.无名管道的使用初探：

子进程写，父进程读。

#include<stdio.h>
#include<unistd.h>
#include<string.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/wait.h>

#define SIZE 128

//父子进程间使用无名管道通讯
int main(void)
{
    int ret = -1;
    int fd[2] = {0};
    char buf[SIZE] = {0};
    pid_t pid = -1;

    //创建一个无名管道，fd[0]用于读，fd[1]用于写
    ret = pipe(fd);
    if(-1 == ret)
    {
        perror("pipe");
        goto err0;
    }

    //创建子进程
    pid = fork();
    if(-1 == pid)
    {
        perror("fork");
        goto err0;
    }

    //子进程 写管道
    if(0 == pid)
    {
        memset(buf, 0, SIZE);
        strcpy(buf, "hello man");
        close(fd[0]);//关闭读端

        ret = write(fd[1], buf, strlen(buf));
        if(-1 == ret)
        {
            perror("write");
            close(fd[1]);
            exit(1);
        }
        printf("子进程写管道字节数 ret = %d\n", ret);
        close(fd[1]);
        exit(0);
    }

    //父进程 读管道
    close(fd[1]);//关闭写端
    //wait(NULL);//等待子进程退出
    memset(buf, 0, SIZE);
    ret = read(fd[0], buf, SIZE);//子进程写端未关闭而管道内又无内容时，这里会阻塞等待有内容时再读取
    if(-1 == ret)
    {
        perror("read");
        goto err1;
    }
    printf("从管道中读取的数据：%s\n", buf);
    close(fd[0]);

    return 0;
err1:
    close(fd[0]);
    close(fd[1]);
err0:
    return 1;
}

3-3 无名管道的使用

子进程循环写，父进程只读一次。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

#define SIZE 128

//父子进程使用无名管道通讯
int main(void)
{
    int ret = -1;
    int status = -1;
    int fd[2] = {0};

    char buf[SIZE];

    pid_t pid = -1;

    //创建一个无名管道
    //fd[0]: 读
    //fd[1]: 写
    ret = pipe(fd);
    if (-1 == ret)
    {
        perror("pipe"); 
        goto err0;
    }

    //创建子进程
    pid = fork();
    if (-1 == pid)
    {
        perror("fork"); 
        goto err1;
    }

    //子进程 不停地写管道
    if (0 == pid)
    {
        //关闭读端
        close(fd[0]);

        printf("hello world child process\n");

        while(1)
        {
            //sleep(1);
            memset(buf, 0, SIZE); 
            strcpy(buf, "hello blackview");

            printf("hello child process while\n");
            //写管道 
            //1. 如果管道被写满了 那么写管道就会阻塞
            //2. 如果管道的读端全部被关闭，那么写管道直接被signal杀死
            ret = write(fd[1], buf, strlen(buf));
            if (ret <= 0)
            {
                perror("write"); 
                break;
            }
            printf("子进程写管道字节数 ret = %d\n", ret); 
        }

        printf("子进程退出...\n");
        close(fd[1]);
        exit(0); 
    }


    //父进程 读管道
    //关闭写端
    close(fd[1]);
    //关闭读端
    close(fd[0]);

    //等待子进程退出
    wait(&status);
    if (WIFSIGNALED(status))
    {
        printf("child proces is killed by signal:%d\n",  WTERMSIG(status)); 
    }

#if 0
    memset(buf, 0, SIZE);
    //从管道中读取数据 管道默认是阻塞
    ret = read(fd[0], buf, SIZE);
    if (-1 == ret)
    {
        perror("read"); 
        goto err1;
    }

    printf("从管道中读取的数据: %s\n", buf);

    close(fd[0]);
#endif
    return 0;
err1:
    close(fd[0]);
    close(fd[1]);
err0:
    return 1;
}

3-4.无名管道的使用

 验证：

1.如果管道中没有数据，那么读管道进程默认会阻塞；

2.如果写端被全部关闭，那么读管道的进程读管道函数会结束阻塞并返回0。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

#define SIZE 128

//父子进程使用无名管道通讯
int main(void)
{
    int ret = -1;
    int status = -1;
    int fd[2] = {0};

    char buf[SIZE];

    pid_t pid = -1;

    //创建一个无名管道
    //fd[0]: 读
    //fd[1]: 写
    ret = pipe(fd);
    if (-1 == ret)
    {
        perror("pipe"); 
        goto err0;
    }

    //创建子进程
    pid = fork();
    if (-1 == pid)
    {
        perror("fork"); 
        goto err1;
    }

    //子进程 不停地写管道
    if (0 == pid)
    {
        //关闭读端
        close(fd[0]);

#if 0 //验证；管道无内容，读端默认阻塞
        printf("hello world child process\n");

        //睡眠10秒
        sleep(10);

        //sleep(1);
        memset(buf, 0, SIZE);
        strcpy(buf, "hello blackview");

        ret = write(fd[1], buf, strlen(buf));
        if (ret <= 0)
        {
            perror("write");
        }
        printf("子进程写管道字节数 ret = %d\n", ret);

        printf("子进程退出...\n");
#endif
        close(fd[1]);
        exit(0);
    }


    //父进程 读管道
    //关闭写端
    close(fd[1]);

#if 0
    //等待子进程退出
    wait(&status);
    if (WIFSIGNALED(status))
    {
        printf("child proces is killed by signal:%d\n",  WTERMSIG(status));
    }
#endif

    memset(buf, 0, SIZE);
    //从管道中读取数据 管道默认是阻塞
    //1. 如果管道中没有数据，那么读管道进程会阻塞
    //2. 如果写端全部关闭，那么读管道的进程读管道返回0
    ret = read(fd[0], buf, SIZE);
    printf("ret:%d\n", ret);
    if (-1 == ret)
    {
        perror("read");
        goto err1;
    }

    printf("从管道中读取的数据: %s\n", buf);

    close(fd[0]);

    return 0;
err1:
    close(fd[0]);
    close(fd[1]);
err0:
    return 1;
}

3-5 无名管道的使用

 读端非阻塞属性的使用（管道无内容，读端不等待，直接返回-1）。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <fcntl.h>

#define SIZE 128

//父子进程使用无名管道通讯
int main(void)
{
    int ret = -1;
    int status = -1;
    int arg = -1;
    int fd[2] = {0};

    char buf[SIZE];

    pid_t pid = -1;

    //创建一个无名管道
    //fd[0]: 读
    //fd[1]: 写
    ret = pipe(fd);
    if (-1 == ret)
    {
        perror("pipe"); 
        goto err0;
    }

    //创建子进程
    pid = fork();
    if (-1 == pid)
    {
        perror("fork"); 
        goto err1;
    }

    //子进程 不停地写管道
    if (0 == pid)
    {
        //关闭读端
        close(fd[0]);

#if 0
        printf("hello world child process\n");

        //睡眠10秒
        sleep(10);

        //sleep(1);
        memset(buf, 0, SIZE); 
        strcpy(buf, "hello blackview");

        ret = write(fd[1], buf, strlen(buf));
        if (ret <= 0)
        {
            perror("write"); 
        }
        printf("子进程写管道字节数 ret = %d\n", ret); 

        printf("子进程退出...\n");
#endif
        sleep(10);

        close(fd[1]);
        exit(0); 
    }


    //父进程 读管道
    //关闭写端
    close(fd[1]);

#if 0
    //等待子进程退出
    wait(&status);
    if (WIFSIGNALED(status))
    {
        printf("child proces is killed by signal:%d\n",  WTERMSIG(status)); 
    }
#endif

    //获取文件描述符属性
    arg = fcntl(fd[0], F_GETFL); 
    //设置非阻塞
    arg = arg | O_NONBLOCK;
    //设置文件描述符属性
    fcntl(fd[0], F_SETFL, arg);

    memset(buf, 0, SIZE);
    //从管道中读取数据 管道默认是阻塞
    //1. 如果写端没有关闭, 读端设置为非阻塞，如果没有数据读， 那么就直接返回-1
    ret = read(fd[0], buf, SIZE);
    printf("ret:%d\n", ret);
    if (-1 == ret)
    {
        perror("read"); 
        goto err1;
    }

    printf("从管道中读取的数据: %s\n", buf);

    close(fd[0]);

    return 0;
err1:
    close(fd[0]);
    close(fd[1]);
err0:
    return 1;
}

3-6无名管道的使用

写端非阻塞属性的使用（管道已满写端不阻塞等待，直接返回）

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <fcntl.h>

#define SIZE 128

//父子进程使用无名管道通讯
int main(void)
{
    int ret = -1;
    int status = -1;
    int arg = -1;
    int fd[2] = {0};

    char buf[SIZE];

    pid_t pid = -1;

    //创建一个无名管道
    //fd[0]: 读
    //fd[1]: 写
    ret = pipe(fd);
    if (-1 == ret)
    {
        perror("pipe"); 
        goto err0;
    }

    //创建子进程
    pid = fork();
    if (-1 == pid)
    {
        perror("fork"); 
        goto err1;
    }

    //子进程 不停地写管道
    if (0 == pid)
    {
        //关闭读端
        close(fd[0]);

        printf("hello world child process\n");

        //获取文件描述符属性
        arg = fcntl(fd[1], F_GETFL); 
        //设置非阻塞
        arg = arg | O_NONBLOCK;
        //设置文件描述符属性
        fcntl(fd[1], F_SETFL, arg);

        while(1)
        {
            //sleep(1);
            memset(buf, 0, SIZE); 
            strcpy(buf, "hello blackview");

            ret = write(fd[1], buf, strlen(buf));
            if (ret <= 0)
            {
                perror("write"); 
                break;
            }
            printf("子进程写管道字节数 ret = %d\n", ret); 
        }

        printf("子进程退出...\n");

        close(fd[1]);
        exit(0); 
    }


    //父进程 读管道
    //关闭写端
    close(fd[1]);

    //等待子进程退出
    wait(&status);
    if (WIFSIGNALED(status))
    {
        printf("child proces is killed by signal:%d\n",  WTERMSIG(status)); 
    }

    memset(buf, 0, SIZE);
    //从管道中读取数据 管道默认是阻塞
    //1. 如果写端没有关闭, 读端设置为非阻塞，如果没有数据读， 那么就直接返回-1
    ret = read(fd[0], buf, SIZE);
    printf("ret:%d\n", ret);
    if (-1 == ret)
    {
        perror("read"); 
        goto err1;
    }

    printf("从管道中读取的数据: %s\n", buf);

    close(fd[0]);

    return 0;
err1:
    close(fd[0]);
    close(fd[1]);
err0:
    return 1;
}

3-7 无名管道的使用

 查看读、写端缓冲区大小。

#include <stdio.h>
#include <unistd.h>

int main(void)
{
    int ret = -1;
    int fd[2] = {0};

    //创建无名管道
    ret = pipe(fd);
    if (-1 == ret)
    {
        perror("pipe"); 
        goto err0;
    }

    //输出管道缓冲区
    printf("_PC_PIPE_BUF: %ld\n", fpathconf(fd[0], _PC_PIPE_BUF));
    printf("_PC_PIPE_BUF: %ld\n", fpathconf(fd[1], _PC_PIPE_BUF));

    close(fd[0]);
    close(fd[1]);

    return 0;
err0:
    return 1;
}

4.有名管道

命名管道（FIFO)和无名管道（pipe）有一些特点是相同的，不一样的地方在于：
(1)FIFO 在文件系统中作为一个特殊的文件而存在，但 pipe 中的内容却存放在内存中。
(2)当使用 FIFO 的进程退出后，FIFO 文件将继续保存在文件系统中以便以后使用。
(3)FIFO 有名字，不相关的进程可以通过打开命名管道进行通信。 

4-1.有名管道的创建：

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

//创建一个有名管道
int main(void)
{
    int ret = -1;

    ret = mkfifo("./my_fifo", 0644);//有名管道的名字和权限
    if(-1 == ret)
    {
        perror("mkfifo");
        goto err0;
    }
    puts("mkfifo ok...");
    
    return 0;
err0:
    return 1;
}

4-2.有名管道的使用1

 一个进程写，一个进程读。

write.c

#include<stdio.h>
#include<sys/types.h>
#include<string.h>
#include<sys/stat.h>
#include<fcntl.h>

#define SIZE (128)

int main(void)
{
	int ret = 0;
	int fd = -1;
	char buf[SIZE] = {0};
	
	if(0 != access("./myfifo", F_OK))//管道不存在则创建它
	{
		ret = mkfifo("./myfifo", 0777);
		if(0 != ret)
		{
			perror("mkfifo");
			goto err0;
		}
	}
	
	fd = open("./myfifo", O_WRONLY);
	if(-1 == fd)
	{
		perror("open myfifo as write-only");
		goto err0;
	}
	
	sprintf(buf, "%s", "Nothing is impossible for a willing heart!");
	ret = -1;
	ret = write(fd, buf, strlen(buf));//写完后默认是会阻塞的，等待管道内容被读取之后才继续往下执行
	if(-1 == ret)
	{
		perror("write to myfifo");
		goto err1;
	}
	printf("write data length is [%d] ?= [%lu]\n", ret, strlen(buf));
	
	close(fd);
	
	return 0;
err1:
    close(fd);
err0:
	return 1;
}

read.c

#include<stdio.h>
#include<sys/types.h>
#include<string.h>
#include<sys/stat.h>
#include<fcntl.h>

#define SIZE (128)

int main(void)
{
	int ret = 0;
	int fd = -1;
	char buf[SIZE] = {0};
	
	if(0 != access("./myfifo", F_OK))//管道不存在则创建它
	{
		ret = mkfifo("./myfifo", 0777);
		if(0 != ret)
		{
			perror("mkfifo");
			goto err0;
		}
	}
	
	fd = open("./myfifo", O_RDONLY);
	if(-1 == fd)
	{
		perror("open myfifo as read-only");
		goto err0;
	}
	
	ret = -1;
	ret = read(fd, buf, SIZE);//如果管道中无内容，默认是阻塞等待读取的
	if(-1 == ret)
	{
		perror("read data from myfifo");
		goto err1;
	}
	
	printf("buf[%s], length[%d]\n", buf, ret);
	
	close(fd);
	return 0;
err1:
    close(fd);
err0:
    return 1;
}

4-3.有名管道的使用2

 一个进程循环写入，一个进程循环读取。

write.c

#include<stdio.h>
#include<sys/types.h>
#include<string.h>
#include<sys/stat.h>
#include<fcntl.h>

#define SIZE (128)

int main(void)
{
	int ret = 0;
	int fd = -1;
	char buf[SIZE] = {0};
	int cnt = 0;
	
	if(0 != access("./myfifo", F_OK))
	{
		ret = mkfifo("./myfifo", 0644);
		if(0 != ret)
		{
			perror("mkfifo");
			goto err0;
		}
	}
	
	fd = open("./myfifo", O_WRONLY);
	if(-1 == fd)
	{
		perror("open myfifo as write-only");
		goto err0;
	}
	
	while(1)//循环向管道写入数据
	{
		memset(buf, 0, SIZE);
		sprintf(buf, "%d %s", cnt++, "Nothing is impossible for a willing heart!");
		
		ret = -1;
		ret = write(fd, buf, strlen(buf));
		if(-1 == ret)
		{
			perror("write data to myfifo");
			close(fd);
			return 1;
		}
		printf("write data length is [%d] ?= [%lu]\n", ret, strlen(buf));
		sleep(1);
	}
	
	return 0;
err0:
    return 1;
}

read.c

#include<stdio.h>
#include<sys/types.h>
#include<string.h>
#include<sys/stat.h>
#include<fcntl.h>

#define SIZE (128)

int main(void)
{
	int ret = 0;
	int fd = -1;
	char buf[SIZE] = {0};

    if(0 != access("./myfifo", F_OK))
	{
		ret = mkfifo("./myfifo", 0644);
		if(-1 == fd)
		{
			perror("mkfifo");
			goto err0;
		}
	}
	
	fd = open("./myfifo", O_RDONLY);
	if(-1 == fd)
	{
		perror("open myfifo as read-only");
		goto err0;
	}
	
	while(1)//循环读取管道中的数据
	{
		memset(buf, 0, SIZE);
		ret = -1;
		ret = read(fd, buf, SIZE);
		if(-1 == ret)
		{
			perror("read data from myfifo");
			close(fd);
			return 1;
		}
		puts(buf);
	}
	
	return 0;
err0:
    return 1;
}

4-4.有名管道的使用3

两个进程A和B聊天。 

A.c

#include<stdio.h>
#include<sys/types.h>
#include<string.h>
#include<sys/stat.h>
#include<fcntl.h>

#define SIZE (128)

int main(void)
{
	int ret = 0;
	int fd = -1;
	int fd2 = -1;
    char buf[SIZE] = {0};
	
	if(0 != access("./fifo_A", F_OK))
	{
		ret = mkfifo("./fifo_A", 0644);
		if(0 != ret)
		{
			perror("create fifo_A");
			goto err0;
		}
	}
	
	if(0 != access("./fifo_B", F_OK))
	{
		ret = mkfifo("./fifo_B", 0644);
		if(0 != ret)
		{
			perror("create fifo_B");
			goto err0;
		}
	}
	
	fd = open("./fifo_A", O_WRONLY);//此处会默认阻塞等待别处以只读方式打开（如果这里先只写打开的话），再继续往下执行
	if(-1 == fd)
	{
		perror("open fifo_A as write-only");
		goto err0;
	}
	
	fd2 = open("./fifo_B", O_RDONLY);//同理
	if(-1 == fd2)
	{
		perror("open fifo_B as read-only");
		goto err1;
	}
	
	puts("ok, Let's talk:");
	//printf("ok, Let's talk:\n");
	//return 1;
	
	while(1)//先写再读
	{
		memset(buf, 0, SIZE);
		if(NULL == fgets(buf, SIZE, stdin))
		{
			perror("get datas from terminal");
		}
		else
		{
			ret = write(fd, buf, strlen(buf));
			if(-1 == ret)
			{
				perror("write data to fifo_A");
			}
		}
		
		memset(buf, 0, SIZE);
		ret = read(fd2, buf, SIZE);
		if(-1 == ret)
		{
			perror("read data from fifo_B");
		}
		else
		{
			puts(buf);
		}
	}
	close(fd);
	close(fd2);
	return 0;
err1:
    close(fd);
err0:
    return 1;
}

B.c

#include<stdio.h>
#include<sys/types.h>
#include<string.h>
#include<sys/stat.h>
#include<fcntl.h>

#define SIZE (128)

int main(void)
{
	int ret = 0;
	int fd = -1;
	int fd2 = -1;
    char buf[SIZE] = {0};
	
	if(0 != access("./fifo_A", F_OK))
	{
		ret = mkfifo("./fifo_A", 0644);
		if(0 != ret)
		{
			perror("create fifo_A");
			goto err0;
		}
	}
	
	if(0 != access("./fifo_B", F_OK))
	{
		ret = mkfifo("./fifo_B", 0644);
		if(0 != ret)
		{
			perror("create fifo_B");
			goto err0;
		}
	}
	
	fd = open("./fifo_A", O_RDONLY);//此处会默认阻塞等待别处以只写方式打开（如果这里先只读打开的话），再继续往下执行
	if(-1 == fd)
	{
		perror("open fifo_A as write-only");
		goto err0;
	}
	
	fd2 = open("./fifo_B", O_WRONLY);//同理
	if(-1 == fd2)
	{
		perror("open fifo_B as read-only");
		goto err1;
	}
	
	puts("ok, Let's talk:");
	
	while(1)//先读再写
	{
		memset(buf, 0, SIZE);
		ret = read(fd, buf, SIZE);
		if(-1 == ret)
		{
			perror("read data from fifo_A");
		}
		else
		{
			puts(buf);
		}
		
		memset(buf, 0, SIZE);
		if(NULL == fgets(buf, SIZE, stdin))
		{
			perror("get datas from terminal");
		}
		else
		{
			ret = write(fd2, buf, strlen(buf));
			if(-1 == ret)
			{
				perror("write data to fifo_B");
			}
		}
	}
	close(fd);
	close(fd2);
	return 0;
err1:
    close(fd);
err0:
    return 1;
}

4-5.有名管道的使用4

两个进程A和B聊天，加入线程防阻塞。

A.c

#include<stdio.h>
#include<sys/types.h>
#include<string.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<pthread.h>

#define SIZE (128)

void* writeData(void* arg)
{
	int ret = -1;
	int fd = *(int*)arg;
	char buf[SIZE] = {0};
	
	while(1)
	{
		memset(buf, 0, SIZE);
		if(NULL == fgets(buf, SIZE, stdin))
		{
			perror("get datas from terminal");
		}
		else
		{
			ret = write(fd, buf, strlen(buf));
			if(-1 == ret)
			{
				perror("write data to fifo_A");
			}
		}
		//usleep(200 * 1000);
	}
	
	return NULL;
}

int main(void)
{
	int ret = 0;
	int fd = -1;
	int fd2 = -1;
    char buf[SIZE] = {0};
	pthread_t writeThread;
	
	if(0 != access("./fifo_A", F_OK))
	{
		ret = mkfifo("./fifo_A", 0644);
		if(0 != ret)
		{
			perror("create fifo_A");
			goto err0;
		}
	}
	
	if(0 != access("./fifo_B", F_OK))
	{
		ret = mkfifo("./fifo_B", 0644);
		if(0 != ret)
		{
			perror("create fifo_B");
			goto err0;
		}
	}
	
	fd = open("./fifo_A", O_WRONLY);//此处会默认阻塞等待别处以只读方式打开（如果这里先只写打开的话），再继续往下执行
	if(-1 == fd)
	{
		perror("open fifo_A as write-only");
		goto err0;
	}
	
	fd2 = open("./fifo_B", O_RDONLY);//同理
	if(-1 == fd2)
	{
		perror("open fifo_B as read-only");
		goto err1;
	}
	
	puts("ok, Let's talk:");
	
	ret = pthread_create(&writeThread, NULL, (void*)writeData, (void*)&fd);//创建线程循环向A写入
	if(0 != ret)
	{
		perror("pthread_create");
		goto err2;
	}
	
	while(1)//循环从B读取
	{
		memset(buf, 0, SIZE);
		ret = read(fd2, buf, SIZE);
		if(-1 == ret)
		{
			perror("read data from fifo_B");
		}
		else
		{
			printf("B:%s", buf);
		}
		//usleep(200 * 1000);
	}
	close(fd);
	close(fd2);
	return 0;
err2:
    return ret;
err1:
    close(fd);
err0:
    return 1;
}

B.c

#include<stdio.h>
#include<sys/types.h>
#include<string.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<pthread.h>
#define SIZE (128)

void* readData(void* arg)
{
	int ret = -1;
	int fd = *(int*)arg;
	char buf[SIZE] = {0};
	
	while(1)
	{
		memset(buf, 0, SIZE);
		ret = read(fd, buf, SIZE);
		if(-1 == ret)
		{
			perror("read data from fifo_A");
		}
		else
		{
			printf("A:%s", buf);
		}
		//usleep(200*1000);
	}
	
	return NULL;
}

int main(void)
{
	int ret = 0;
	int fd = -1;
	int fd2 = -1;
    char buf[SIZE] = {0};
	pthread_t readThread;
	
	if(0 != access("./fifo_A", F_OK))
	{
		ret = mkfifo("./fifo_A", 0644);
		if(0 != ret)
		{
			perror("create fifo_A");
			goto err0;
		}
	}
	
	if(0 != access("./fifo_B", F_OK))
	{
		ret = mkfifo("./fifo_B", 0644);
		if(0 != ret)
		{
			perror("create fifo_B");
			goto err0;
		}
	}
	
	fd = open("./fifo_A", O_RDONLY);//此处会默认阻塞等待别处以只写方式打开（如果这里先只读打开的话），再继续往下执行
	if(-1 == fd)
	{
		perror("open fifo_A as write-only");
		goto err0;
	}
	
	fd2 = open("./fifo_B", O_WRONLY);//同理
	if(-1 == fd2)
	{
		perror("open fifo_B as read-only");
		goto err1;
	}
	
	puts("ok, Let's talk:");
	
	ret = pthread_create(&readThread, NULL, (void*)readData, (void*)&fd);//创建线程循环从A读取
	if(0 != ret)
	{
		perror("pthread_create");
		goto err2;
	}
	
	while(1)//循环向B写入
	{
		memset(buf, 0, SIZE);
		if(NULL == fgets(buf, SIZE, stdin))
		{
			perror("get datas from terminal");
		}
		else
		{
			ret = write(fd2, buf, strlen(buf));
			if(-1 == ret)
			{
				perror("write data to fifo_B");
			}
		}
		//usleep(200*1000);
	}
	close(fd);
	close(fd2);
	return 0;
err2:
    return ret;
err1:
    close(fd);
err0:
    return 1;
}

5.内存映射

1.映射函数mmap的使用

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>


int main(void)
{
    int fd = -1;
    int len = 0;

    void *addr = NULL;

    //打开文件
    fd = open("txt", O_RDWR | O_CREAT, 0644);
    //fd = open("txt", O_RDONLY);
    if (-1 == fd){
        perror("open"); 
        goto err0;
    }
    
    //获取文件长度
    len = lseek(fd, 0, SEEK_END);
    if (-1 == len){
        perror("lseek"); 
        goto err1;
    }
    printf("fd:%d len: %d\n", fd, len);

    //映射
    //MAP_PRIVATE : 对映射区的写入操作会产生一个映射区的复制(copy - on - write), 对此区域所做的修改不会写回原文件。
    //addr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
    addr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (MAP_FAILED == addr){
        perror("mmap"); 
        goto err1;
    }

    //addr++;
    printf("映射ok....\n");
    
    //关闭文件
    close(fd);

    strcpy(addr, "hello itcast"); 

    printf("%s\n", (char*)(addr + 1));

    //解除映射
    munmap(addr, len);

    return 0;
err1:
    close(fd);
err0:
    return 1;
}

2.用于父子进程通信

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>


int main(void)
{
    int fd = -1;
    int len = 0;

    pid_t pid = -1;

    void *addr = NULL;

    //打开文件
    fd = open("txt", O_RDWR | O_CREAT, 0644);
    //fd = open("txt", O_RDONLY);
    if (-1 == fd)
    {
        perror("open"); 
        goto err0;
    }
    
    //获取文件长度
    len = lseek(fd, 0, SEEK_END);
    if (-1 == len)
    {
        perror("lseek"); 
        goto err1;
    }
    printf("fd:%d len: %d\n", fd, len);

    //映射
    //MAP_PRIVATE : 对映射区的写入操作会产生一个映射区的复制(copy - on - write), 对此区域所做的修改不会写回原文件。
    //addr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
    addr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (MAP_FAILED == addr)
    {
        perror("mmap"); 
        goto err1;
    }

    //addr++;
    printf("映射ok....\n");
    //关闭文件
    close(fd);


    //创建一个子进程
    pid = fork();
    if (-1 == pid)
    {
        perror("fork"); 
        goto err0;
    }

    //子进程
    if (0 == pid)
    {
        //写映射区
        strcpy(addr, "hello itcast"); 
        printf("子进程退出....\n");

        //解除映射
        munmap(addr, len);

        exit(0);
    }

    //等待子进程退出
    wait(NULL);

    //父进程
    printf("%s\n", (char*)addr);

    //解除映射
    munmap(addr, len);

    return 0;
err1:
    close(fd);
err0:
    return 1;
}

3.普通进程间通信

3.1 read.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>


int main(void)
{
    int fd = -1;
    int len = 0;

    void *addr = NULL;

    //打开文件
    fd = open("txt", O_RDWR | O_CREAT, 0644);
    if (-1 == fd)
    {
        perror("open"); 
        goto err0;
    }
    
    //获取文件长度
    len = lseek(fd, 0, SEEK_END);
    if (-1 == len)
    {
        perror("lseek"); 
        goto err1;
    }
    printf("fd:%d len: %d\n", fd, len);

    //映射
    //MAP_PRIVATE : 对映射区的写入操作会产生一个映射区的复制(copy - on - write), 对此区域所做的修改不会写回原文件。
    //addr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
    addr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (MAP_FAILED == addr)
    {
        perror("mmap"); 
        goto err1;
    }

    //addr++;
    printf("映射ok....\n");
    
    //关闭文件
    close(fd);

    printf("addr: %s\n", (char*)addr);

    //解除映射
    munmap(addr, len);

    return 0;
err1:
    close(fd);
err0:
    return 1;
}

3.2 write.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>


int main(void)
{
    int fd = -1;
    int len = 0;

    void *addr = NULL;

    //打开文件
    fd = open("txt", O_RDWR | O_CREAT, 0644);
    //fd = open("txt", O_RDONLY);
    if (-1 == fd)
    {
        perror("open"); 
        goto err0;
    }
    
    //获取文件长度
    len = lseek(fd, 0, SEEK_END);
    if (-1 == len)
    {
        perror("lseek"); 
        goto err1;
    }
    printf("fd:%d len: %d\n", fd, len);

    //映射
    //MAP_PRIVATE : 对映射区的写入操作会产生一个映射区的复制(copy - on - write), 对此区域所做的修改不会写回原文件。
    //addr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
    addr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (MAP_FAILED == addr)
    {
        perror("mmap"); 
        goto err1;
    }

    //addr++;
    printf("映射ok....\n");
    
    //关闭文件
    close(fd);

    strcpy(addr, "hello itcast"); 


    //解除映射
    munmap(addr, len);

    return 0;
err1:
    close(fd);
err0:
    return 1;
}

4.匿名映射

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>


int main(void)
{
    int len = 0;

    pid_t pid = -1;

    void *addr = NULL;

    len = 1024;

    //创建一个匿名映射
    addr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
    if (MAP_FAILED == addr)
    {
        perror("mmap"); 
        goto err1;
    }

    //addr++;
    printf("创建匿名映射ok....\n");


    //创建一个子进程
    pid = fork();
    if (-1 == pid)
    {
        perror("fork"); 
        goto err0;
    }

    //子进程
    if (0 == pid)
    {
        //写映射区
        strcpy(addr, "hello itcast"); 
        printf("子进程退出....\n");

        //解除映射
        munmap(addr, len);

        exit(0);
    }

    //等待子进程退出
    wait(NULL);

    //父进程
    printf("%s\n", (char*)addr);

    //解除映射
    munmap(addr, len);

    return 0;
err1:
err0:
    return 1;
}

未解供耕织
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux进程间通信 共享内存+信号量+简单例子
无名小鱼
08-19 8370
每一个进程都有着自己独立的地址空间，比如程序之前申请了一块内存，当调用fork函数之后，父进程和子进程所使用的是不同的内存。因此进程间的通信，不像线程间通信那么简单。但是共享内存编程接口可以让一个进程使用一个公共的内存区段，这样我们便能轻易的实现进程间的通信了（当然对于此内存区段的访问还是要控制好的）。 共享内存实现进程通信的优点： 共享内存是进程通信方式中最快速的方式之一，它的快速体现在，为
Linux下的进程间通信
ChenYang1998的博客
03-31 212
进程间通信 我们知道，在进程运行期间，每个进程都是相互独立的，而有的时候，我们需要将多个一个进程的数据传输给另外一个进程，或者实现多个进程共享同一份资源，又或者是一个进程发消息给另外一个进程，此时。就需要进行多个进程之间的通信，本文将在linux操作系统下简介进程间通信的基本概念以及方法。 1.进程间通信的分类 *管道通信（分匿名管道和命名管道） *System V IPC（主要有三种方式
Linux进程间通信(IPC)demo
少言才不会咸's Tech-blog
11-25 604
/* 1、编写两个进程a和b，利用共享内存技术，a向共享内存写字符串，b将从共享内存中读到的字符串在屏幕上打印出来。 */#include <stdio.h> #include <stdlib.h> #include <sys/ipc.h> #include <sys/shm.h> #include <string.h> #include <unistd.h>int main(int argc, c
四种进程间通信的方式demo
12-14
四种进程间通信的方式：activity 、service AIDL 、ContentProvider 、BroadcastReceiver 一个客户端一个服务端，相互通信
进程间通讯demo
Lua programming language
12-23 257
// 使用Memory Mapping file共享数据，使用一个Event作为并发控制。 // 仅为练习使用。 #define BUFFER_SIZE (100*1024) #define BUFSIZE 1024 struct BufferStruct { BOOL hasRead; TCHAR buf[512]; }; void ...
Linux进程间通信
注意路标
07-21 168
引言 进程间除了可以使用 fork和exec传送打开的文件，也可以使用IPC（Inter Processing Communication）的方式通信。 经典的IPC包括：管道、FIFO、消息队列、信号量、以及共享存储。 在新的程序中要尽可能的避免使用消息队列和信号量，应该考虑全双工管道和记录锁，他们使用会更加的简单。共享存储依然有它的用途，虽然使用mmap函数也能提供同样的功能。 管道 管...
操作系统进程间通信管道demo
06-03
在这个"操作系统进程间通信管道demo"中，我们重点探讨的是管道（Pipe）这种简单的IPC机制。管道是早期UNIX系统中引入的一种通信方式，至今仍被广泛使用。 管道是一种半双工的通信方式，数据只能单向流动，但可以有...
linux下socket通信源码.doc
06-12
在Linux环境下，Socket通信是进程间通信的一种常见方式，它基于网络协议，允许不同设备间的程序交换数据。这里我们分析的源码包含了两个文件：`talker.c` 和 `server.c`，分别代表一个UDP（用户数据报协议）客户端...
在Linux下的网络编程demo，C语言实现了多进程和多线程的并发服务器案例，client-server demo.zip
最新发布
06-13
- **套接字（Sockets）**: 套接字是网络通信的基本接口，它是进程间通信的一种方式，使得运行在不同主机上的程序能够相互通信。 - **TCP/IP协议栈**: TCP（传输控制协议）和IP（网际协议）是互联网最核心的两个...
进程间的通讯demo——fifo
03-12
在这个“进程间的通讯demo——fifo”中，我们将深入探讨如何使用FIFO（First-In-First-Out，先进先出）作为进程间通信的一种机制。 FIFO，也被称为命名管道，是一种简单的IPC形式，其工作原理类似于物理世界的管道...
server_client_demo.rar
06-07
Socket是操作系统提供的一种进程间通信（IPC，Inter-Process Communication）机制，尤其适用于网络环境。它允许不同计算机上的进程之间进行数据交换，是构建网络应用程序的基础。在Linux系统中，socket API是基于...
Linux 进程通信-共享内存Shmem示例
读书未遍、未敢妄下雌黄
12-18 3590
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Ma...
Linux进程间通信，代码简单，一看就懂。
ZMCITY的博客
04-26 2406
1、无名管道 关键函数 pipe(); write(); read(); close(); 代码 #include&lt;unistd.h&gt; #include&lt;stdio.h&gt; int main(void) { int fd[2];//定义管道 pipe(fd);//创建管道，失败返回-1 pid_t pid = fork();//返回值为...
进程间通信的方式总结（特点，以及code demo）
李政的博客
10-08 8999
进程间通信（IPC，InterProcess Communication）：是指在不同进程之间传播或交换信息。 一、简单的进程间通信： 命令行：父进程通过exec函数创建子进程时可以附加一些数据。 环境变量：父进程通过exec函数创建子进程顺便传递一张环境变量表。 信号：父子进程之间可以根据进程号相互发送信号，进程简单通信。 文件：一个进程向文件中写入数据，另一个进程从文件中读取出来。 命令行...
1.进程间的五种通信方式
枕上青灯竹书香的博客
04-22 1013
1、进程间通信（IPC）介绍： 进程间通信（IPC，InterProcess Communication）是指在不同的进程之间传播或交换信息。 IPC的方式有管道（包括无名管道和命名管道）、消息队列、信号量、共享内存、Socket、Streams等。其中Socket和Streams支持不同主机上的两个进程间通信。 2、管道 管道，通常指无名管道，是 UNIX 系统IPC最古老的形式。 特点： 它是半双工的（即数据只能在一个方向上流动），具有固定的读端和写端。 它只能用于具有亲缘关系的进程之间的
linux进程间的通信（详细且有demo）
qq_54402650的博客
08-28 1818
进程间通信常用的几种方式
Linux-进程间通信之无名管道和有名管道demo
一只青木呀
07-29 500
linux-IPCs Linux进程间通信方式汇总 目前已包含的方式 管道(PIPE) 无名管道 FIFO(有名管道) XSI消息队列 XSI信号量 XSI共享内存 POSIX信号量 域套接字(Domain Socket) 信号(Signal) 互斥量(Mutex) sendmsg 其中信号(signal)和信号量(semaphore)本质上并不算是进程间通信方式，应该是进程间同步的方式，但是也可以起到一定的通信作用，故也列在上面。 另外普通的mutex是作用线程间同步用的，但是可以将进程A和进程B共享
c++在类外调用类的私有成员函数的两种方法
热门推荐
m0_37829435的博客
08-02 2万+
 1.通过类的public成员函数调用private成员函数: #include&lt;iostream&gt; using namespace std; class Test { public: void fun2() { fun1(); } private: void fun1() ...
消息队列递归实现进程间通信demo
05-18
下面是一个简单的消息队列递归实现进程间通信的demo，可以供您参考： ```python import queue class MsgNode: def __init__(self, msg, sender, receiver): self.msg = msg self.sender = sender self....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值