Different communication objects and communication methods

1. Pipeline: one is nameless pipeline and the other is famous pipeline

There is no file node in the file system

Unnamed Pipes

Communication principle:

  Pipeline file is a special file, which is implemented by queue.

Creating a file or opening a file in file IO is implemented by the open function, which cannot create a pipeline file. Pipes can only be created with the pipe function.

File open - only ordinary files can be created or opened. It cannot create pipeline files. Pipes can only be created with the pipe function.

Create pipe - pipe

Function form: int pipe(int fd[2]);

 #include <unistd.h>

 int pipe(int pipefd[2]);

Function: create a pipe for system call: unistd.h

Parameter: is the file descriptor obtained. It can be seen that there are two file descriptors: fd[0] and fd[1]. The pipeline has a read end fd[0] for reading and a write end fd[1] for writing. This rule cannot be changed.

Return value: success is 0, error is - 1  

Example 1: use the pipe function.

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main()
{
        int fd[2];
        int ret;
        ret=pipe(fd);
        if(ret<0)
        {
                printf("creat pipe failure\n");
                return -1;
        }
        printf("creat pipe sucess fd[0]=%d,fd[1]=%d\n",fd[0],fd[1]);
        return 0;
}

The results are as follows:

  Successfully created pipeline, fd[0]=3,fd[1]=4

The pipeline has a read side fd[0] for reading and a write side fd[1] for writing

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main()
{
	int fd[2];
	int ret;
	char write_buf[]="hello kiki";
	char read_buf[128]={0};
	ret=pipe(fd);
	if(ret<0)
	{
		printf("creat pipe failure\n");
		return -1;
	}
	printf("creat pipe sucess fd[0]=%d,fd[1]=%d\n",fd[0],fd[1]);

	write(fd[1],write_buf,sizeof(write_buf));
	//start read from pipe
	
	read(fd[0],read_buf,128);
	printf("read_buf=%s\n",read_buf);

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

The results are as follows:

be careful:

-The pipeline is created in memory. When the process ends and the space is released, the pipeline does not exist;

-The things in the pipeline are deleted after reading; Queue - after leaving the queue, the contents of the queue are no longer there

-If there is nothing readable in the pipe, it will be blocked.

Example 2: verify read blocking

 
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
	int fd[2];
	int ret;
	char write_buf[]="hello kiki";
	char read_buf[128]={0};
	ret=pipe(fd);
	if(ret<0)
	{
		printf("creat pipe failure\n");
		return -1;
	}
	printf("creat pipe sucess fd[0]=%d,fd[1]=%d\n",fd[0],fd[1]);

	write(fd[1],write_buf,sizeof(write_buf));
	//start read from pipe
	
	read(fd[0],read_buf,128);
	printf("read_buf=%s\n",read_buf);

	//second read from pipe
	
	memset(read_buf,0,128);

	read(fd[0],read_buf,128);
	printf("second read after\n ");

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

The results are as follows:

 

Example 3: verify write blocking: you can calculate the size of the pipeline opened by the kernel. sixty-five thousand five hundred and thirty-six  

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
	int fd[2];
	int ret;
	int i=0;
	char write_buf[]="hello kiki";
	char read_buf[128]={0};
	ret=pipe(fd);
	if(ret<0)
	{
		printf("creat pipe failure\n");
		return -1;
	}
	printf("creat pipe sucess fd[0]=%d,fd[1]=%d\n",fd[0],fd[1]);
	while(i<6500)
	{
		write(fd[1],write_buf,sizeof(write_buf));
		i++;
	}

	printf("write pipe end\n");

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

The results are as follows:

  If the write is blocked and the following printf statement will not be executed, it indicates that the pipeline is full

Example 4: process communication

#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
int main()
{
	pid_t pid;
	int fd[2];
	char process_inter=0;
	int ret=pipe(fd);
	if(ret<0)
	{
		printf("creat pipe failure\n");
		return -1;
	}
	printf("creat pipe sucess\n");
	pid = fork();
	
	if(pid==0)
	{
		int i=0;
		read(fd[0],&process_inter,1);//if pipe empty sleep
		while(process_inter==0);
		for(i=0;i<5;i++)
		{
			printf("this is child process i=%d\n",i);
			usleep(100);
		}
	}
	if(pid>0)
	{
		int i=0;
		for(i=0;i<5;i++)
		{
			printf("this is parent process i=%d\n",i);
			usleep(100);
		}
		process_inter=1;
		sleep(3);
		write(fd[1],&process_inter,1);
	}
	while(1);
	return 0;
}

The results are as follows:

 

Disadvantages of anonymous pipeline: communication between processes that are not parent-child (kinship) cannot be realized.