无名管道和有名管道的概念与实现

1.管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道；

2.只能用于父子进程或者兄弟进程之间（具有亲缘关系的进程）；

3.单独构成一种独立的文件系统：管道对于管道两端的进程而言，就是一个文件，但它不是普通的文件，它不属于某种文件系统，而是自立门户，单独构成一种文件系统，并且只存在与内存中。

4.数据的读出和写入：一个进程向管道中写的内容被管道另一端的进程读出。写入的内容每次都添加在管道缓冲区的末尾，并且每次都是从缓冲区的头部读出数据。

5.从管道中读取数据：

如果管道的写端不存在，则认为已经读到了数据的末尾，读函数返回的读出字节数为0；

当管道的写端存在时，如果请求的字节数目大于PIPE_BUF，则返回管道中现有的数据字节数，如果请求的字节数目不大于PIPE_BUF，则返回管道中现有数据字节数（此时，管道中数据量小于请求的数据量）；或者返回请求的字节数（此时，管道中数据量不小于请求的数据量）。注：（PIPE_BUF在include/linux/limits.h中定义，不同的内核版本可能会有所不同。Posix.1要求PIPE_BUF至少为512字节，red hat 7.2中为4096）。

6.向管道中写入数据：

向管道中写入数据时，linux将不保证写入的原子性，管道缓冲区一有空闲区域，写进程就会试图向管道写入数据。如果读进程不读走管道缓冲区中的数据，那么写操作将一直阻塞。

注：只有在管道的读端存在时，向管道中写入数据才有意义。否则，向管道中写入数据的进程将收到内核传来的SIFPIPE信号，应用程序可以处理该信号，也可以忽略（默认动作则是应用程序终止）。

7。管道的主要局限性正体现在它的特点上：

只支持单向数据流；

这个实验创建了一个管道，并且实现了读写的操作

/*
 ============================================================================
 Name        : pipe.c
 Author      : 
 Version     :
 Copyright   : Your copyright notice
 Description : Hello World in C, Ansi-style
 ============================================================================
 */

#include <stdio.h>
#include <stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<string.h>
int main(void) {
	int fd[2];
	int ret;
	char p[20];
	char *buf="hello!,pipe";
	ret=pipe(fd);//将数组名传进去
	//p=buf;这个是错的，buf是一个变量，p[20]是变量，但是p是常量，不能被修改
	//buf=p;这个是对的
	if(ret==-1)
	{
		perror("pipe error");
		exit(0);
	}
	else
	{
		int writeno=write(fd[1],buf,strlen(buf));//接受一下返回值，表示读了多少个数字
		if(writeno==-1)
		{
			perror("write error");
			exit(1);//这时最好不要用负数，因为会影响到sataus，对于负数他是用补码保存的负数
		}
		int readno=read(fd[0],p,20);
		if(readno==-1)
		{
			perror("read error");
			exit(1);
		}
		p[readno]='\0';
		printf("read pipe:%s\n",p);
		exit(0);
	}

	return EXIT_SUCCESS;
}

结果：read pipe:hello!,pipe

只能用于具有亲缘关系的进程之间；

没有名字；

管道的缓冲区是有限的（管道制存在于内存中，在管道创建时，为缓冲区分配一个页面大小）；

管道所传送的是无格式字节流，这就要求管道的读出方和写入方必须事先约定好数据的格式，比如多少字节算作一个消息（或命令、或记录）等等；

管道应用的一个重大限制是它没有名字，因此，只能用于具有亲缘关系的进程间通信

创建管道的方式：

int  fd[2]

pipe(fd);

这里的pipe函数的返回值：当成功时返回0，失败时返回1，fd[0]代表这读端，fd[1]代表着写端

8.无名管道要注意的几个问题

（1）：交换管道的读写端，也就是将fd[0]换成fd[1],运行程序是会出错的，因为，读端只有读权限，写端只有写权限，一旦调换，权限将不允许，从而出现错误

（2）：关闭管道写端，从读端读数据.read函数返回值为0，表示读管道文件尾。

（3）：关闭管道读端，从写端写数据。 write error: Broken pipe。

            此时出现管道破裂内核会向当前进程发送SIGPIPE信号，用户进程对于此信号的默认处理方式为终止当前进 程。

tcp编程中：当通信的一端将套接字关闭，此时内核会向调用write函数的进程发送SIGPIPE信号，用户进程对于此进程的默认处理方式为终止当前进程。

（4）：不关闭写端，从读端读数据： 此时read阻塞，直到写端有数据写入时，read 函数返回

fcntl函数可以设置读管道时不阻塞。

（5）：不关闭读端，直接写数据：是可以写入的

（6）：多次写入一次读取。如果读取的buf够大，会将管道中所有的数据读出。

（7）：一次写入（10）多次读取（10）。这个是好只能读出一次，第二次读的时候管道中无数据，read函数阻塞

通过利用同步互斥的原理实现进程间的通信：

/*
 ============================================================================
 Name        : child2ConnecByLock.c
 Author      :
 Version     :
 Copyright   : Your copyright notice
 Description : Hello World in C, Ansi-style
 ============================================================================
 */

#include <stdio.h>
#include <stdlib.h>
#include<unistd.h>
#include<sys/stat.h>
#include<sys/types.h>
#include<sys/wait.h>
#include<string.h>
int main(void) {
        int fd[2];
        char buf1[20],buf2[20];
        int ret=pipe(fd);
        pid_t pid,pid2;
        if(ret==-1)
        {
            perror("create pipe wrong!");
            exit(0);
        }
       pid=fork();
        if(pid==0)
        {

            lockf(fd[1],1,0);//锁定对整个文件的写操作
            strcpy(buf2,"child peocess1");
            int writeno1=write(fd[1],buf2,20);
            if(writeno1==-1)
            {
                perror("child1 1 wrong！");
                exit(1);
            }
            sleep(1);
            lockf(fd[1],0,0);//锁定对整个文件的写操作
            exit(1);
        }
        else if(pid>0)
        {
            pid2=fork();
           if(pid2==0)
            {
                    lockf(fd[1],1,0);
                    strcpy(buf2,"child process2");
                    int writeno2=write(fd[1],buf2,20);
                    if(writeno2==-1)
                    {
                        perror("child 2 wrong!");
                        exit(1);
                    }
                    sleep(3);
                    lockf(fd[1],0,0);
                   exit(1);
            }
           else if(pid2>0)
           {
                      wait(NULL);
                      int readno1=read(fd[0],buf1,20);
                       printf("readno1 = %d",readno1);    
                      buf1[readno1]='\0';
                      printf("%s\n",buf1);

                      wait(NULL);

                      int readno2=read(fd[0],buf2,20);

                     buf2[readno2]='\0';//
;本人这里出现一个非常有意思的地方，当把这个操作删除后，两个进程依
                                //次输出信息，但是如果使用这个操作，虽然同样出现了数组的越界
 printf("%s\n",buf2); exit(0); } } else { perror("carete child wrong!"); exit(1); } return EXIT_SUCCESS;}

有关popen和pclose
:
/*
 ============================================================================
 Name        : popen.c
 Author      : 
 Version     :
 Copyright   : Your copyright notice
 Description : Hello World in C, Ansi-style
 ============================================================================
 */

#include <stdio.h>
#include <stdlib.h>

int main(void) {
	FILE *fp=NULL;
	char buf[100];
	if((fp=popen("ls -l","r"))==NULL)//
	{
		perror("popen wrong");
		exit(1);
	}
	while(fgets(buf,100,fp)!=NULL)
	{
		printf("%s\n",buf);
	}



   if((fp=popen("cat >text","w"))==NULL)
   {
	   perror("popen wrong");
   	exit(1);
   }
   fputs("helloworld!",fp);
	pclose(fp);

	//cat就是把标准输入 输出到标准输出
	//cat >txt,将标准输入输入到txt文件里面去
}