管道——学习笔记

一.管道如何实现进程间的通信：

（1） 父进程创建管道，得到两个⽂件描述符指向管道的两端

（2）父进程fork出子进程，⼦进程也有两个⽂件描述符指向同⼀管道。

（3）父进程关闭fd[0],子进程关闭fd[1]，即⽗进程关闭管道读端,⼦进程关闭管道写端（因为管道只支持单向通信）。⽗进程可以往管道⾥写,⼦进程可以从管道⾥读,管道是⽤环形队列实现的,数据从写端流⼊从读端流出,这样就实现了进程间通信。

（4）管道的创建

管道是由调用pipe函数来创建

#include <unistd.h>
int pipe (int fd[2])；
//返回:成功返回0，出错返回-1     

fd参数返回两个文件描述符,fd[0]指向管道的读端,fd[1]指向管道的写端。fd[1]的输出是fd[0]的输入。

二.管道通信的代码实现示例：

    #include <stdio.h>  
    #include <unistd.h>  
    #include <string.h>  
    #include <errno.h>  
    int main()  
    {  
        int fd[2];  
        int ret = pipe(fd);  
        if (ret == -1)  
        {  
            perror(”pipe error\n”);  //point 3
            return 1;  
        }  
        pid_t id = fork();  //point 2
        if (id == 0)  
        {//child  
            int i = 0;  
            close(fd[0]);  //point 4
            char *child = “I am  child!”;  
            while (i<5)  
            {  
                write(fd[1], child, strlen(child) + 1);//point 5  
                sleep(2);  //point 6
                i++;  
            }  
        }  
        else if (id>0)  
        {//father  
            close(fd[1]);  
            char msg[100];  
            int j = 0;  
            while (j<5)  
            {  
                memset(msg,’\0’,sizeof(msg)); //point 7 
                ssize_t s = read(fd[0], msg, sizeof(msg));  //point 5
                if (s>0)  
                {  
                    msg[s - 1] = ’\0’;  
                }  
                printf(”%s\n”, msg);  
                j++;  
            }  
        }  
        else  
        {//error  
            perror(”fork error\n”);  
            return 2;  
        }  
        return  0;  
    }  

1. 运行结果：

每隔2秒打印一次

I am child!

并且打印了五次。

2. 对于pid_t id = fork();的理解：

这里的pid_t类似一个类型，就像int型一样，int型定义的变量都是整型的，pid_t定义的类型都是进程号类型。这个语句的意思是定义了一个pid_t类型的变量pid，fork()函数返回一个进程号，这个进程号赋给了pid。pid_t在头文件types.h（sys/types.h）中定义。

其中fork( void )为创建子进程，有趣的是他有三种不同的返回值

1、在父进程中，fork返回新创建的子进程的PID

2.、在子进程中，fork返回0

3、如果出现错误，fork返回一个负值

另外在子进程被创建之前，只有一个进程在运行，但在fork创建子进程后，两进程同时运行

程序例子：

int main(int argc ,char *argv )

{

// printf("PID =%d \n",getpid());

// printf("PPID =%d \n",getppid());

    pid_t pid;         //定义一个进程号类型的变量 pid

                             // 在此程序中，此时只有一个进程在运行      

   pid=fork();       // 在此程序中，此时只有两个进程在运行   

   if(pid<0)  

          printf("error in fork!");

   else if (pid==0)

           printf("I am the child process,ID is %d\n",getpid());

   else

            printf("I am the parent process,ID is %d\n",getpid());

    return 0;

}

运行结果：创建了一个子进程，输出的结果为

  I am the parent process,ID is 13655

  I am the child process, ID is 13525，不同次执行时，进程的ID一般是不同的。

pid_t与int又有什么区别呢？

pid_t是typedef定义的类型，表示进程的id

在sys/types.h中定义：

typedef short pid_t;

所以说pid_t就是一个short类型的变量，实际表示的是内核中进程表的索引。

3. C库函数-perror：
   perror（）详解

4. C库函数-close：
   open函数和close函数详解

5. C库函数-write和read：
   read（）和write（）详解

6. C库函数-sleep：
   sleep（）函数详解

7. C库函数-memset：
   memset函数详解