Linux中管道的使用（父或子进程中能否都保留读写端）

[cumirror]

最近在看管道相关的操作，管道可用于父子进程间的IPC。
通常情况下，数据流是单向的（半双工），如对于父->子的管道，在父进中要关闭读端(fd[0])，子进程中关闭写端(fd[1])。对于子->父的管道，在父进中要关闭写端(fd[1])，子进程中关闭读端(fd[0])。

我的问题是，能否在父子进程中对于读写端都不关闭，从而可以实现父子的全双工通讯。

我写了简单的测试代码，输出为:
C
P
kkkkkkkkkkkk

用sleep进行延时，让子进程先执行，由输出看确实先输出了"C"，但为何这时，在父进程中的write(fd[1], "tttttt", 6);无效呢?

code:

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

int main(int argc, char **argv)
{
	int fd[2];
	pid_t pid;
	char get[13];
	if(pipe(fd) < -1){
		printf("Pipe Error!\n");
		return -1;
	}
	if((pid = fork()) < 0){
		printf("Fork Error!\n");
		return -1;
	}else	if(pid > 0){
		/* parent */
		sleep(1);
		printf("P\n");
		write(fd[1], "tttttt", 6);
		read(fd[0], get, 12);
		get[12] = '\0';
		printf("read: %s\n", get);
	}else{
		/* child */
		printf("C\n");
		write(fd[1], "kkkkkkkkkkkk", 12);
	}
	
}

[dongjiawei316]

[Quote=引用楼主 cumirror 的回复:]
我的问题是，能否在父子进程中对于读写端都不关闭，从而可以实现父子的全双工通讯。
[/Quote]
这样是不行的，当父进程和子进程都从一个pipe中读操作，读出来的可能是自己刚刚写进去的。
如果你想全双工的话，使用两个pipe就好了。

[qq120848369]

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

void alrmFunc(int signo)
{
        printf("alarm\n");
        exit(2);
}

void chldFunc(int signo)
{
        pid_t pid;

        while(true)
        {
                pid=waitpid(-1,NULL,WNOHANG);

                if(pid==0)
                {
                        break;
                }
                else if(pid<0)
                {
                        if(errno==ECHILD)
                        {
                                break;
                        }
                }
                else
                {
                        printf("pid:%d exit!\n",pid);
                }
        }
}

int main(int argc, char **argv)
{
    int fd[2];
    pid_t pid;
    char get[13];

        if(signal(SIGCHLD,chldFunc)==SIG_ERR)
        {
                perror("signal");
                exit(1);
        }

    if(pipe(fd) < -1){
        printf("Pipe Error!\n");
        return -1;
    }
    if((pid = fork()) < 0){
        printf("Fork Error!\n");
        return -1;
    }else    if(pid > 0){
        /* parent */
                if(signal(SIGALRM,alrmFunc)==SIG_ERR)
                {
                        perror("signal");
                        exit(1);
                }

        printf("P\n");
        write(fd[1], "tttttt", 6);
                int n;

                alarm(3);

        while( (n=read(fd[0], get, 12))>0 )
                {
                        get[n]='\0';
                        printf("%s",get);
                        fflush(stdout);
                }
                //父进程读光父子进程所有数据
                //但是父进程阻塞在read，没法close pipe[1]
                //所以read也得不到EOF，这就是很纠结的一件事了
                //设置read非阻塞说不定运气不好数据没读全就EAGAIN了
                //可以使用select pipe[0]，设置一个超时值，超时则关闭pipe[1]退出
                //这里我在alarm里退出父进程
                printf("parent exit\n");
                //让父进程退出自动关闭pipe[0] and pipe[1]
    }else{
        /* child */
        printf("C\n");
        write(fd[1], "kkkkkkkkkkkk", 12);
    }

        //子进程退出自动关闭pipe[1],pipe[0].
    //但子进程不是唯一的pipe[1]持有者，所有不发送EOF
        return 0;
}

[qq120848369]

[Quote=引用 3 楼 qq120848369 的回复:]

C/C++ code
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/wait.h>

void alrmFunc(int signo)
{
printf("……
[/Quote]

忘了说楼主为什么读不到，因为你只调用了一次read，当然读不到那么多字符，循环读。

[qq120848369]

[Quote=引用 4 楼 qq120848369 的回复:]

引用 3 楼 qq120848369 的回复:

C/C++ code
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/wait.h>

void alr……
[/Quote]

哦哦，还有一点要提到的，楼主写pipe的数据量小于pipe_buf，所以属于原子写，也就是父子进程写的数据不会穿插，这是很重要的一点。 楼主可以看一下以下帮助：



Write requests to a pipe or FIFO shall be handled in the same way as a regular file with the following exceptions:

* There is no file offset associated with a pipe, hence each write request shall append to the end of the pipe.

* Write requests of {PIPE_BUF} bytes or less shall not be interleaved with data from other processes doing writes on the same pipe. Writes of
greater than {PIPE_BUF} bytes may have data interleaved, on arbitrary boundaries, with writes by other processes, whether or not the O_NONBLOCK
flag of the file status flags is set.

[cumirror]

谢谢LS各位的意见，我下去试验下。

[Linux-Torvalds]

[Quote=引用楼主 cumirror 的回复:]
最近在看管道相关的操作，管道可用于父子进程间的IPC。
通常情况下，数据流是单向的（半双工），如对于父->子的管道，在父进中要关闭读端(fd[0])，子进程中关闭写端(fd[1])。对于子->父的管道，在父进中要关闭写端(fd[1])，子进程中关闭读端(fd[0])。

我的问题是，能否在父子进程中对于读写端都不关闭，从而可以实现父子的全双工通讯。

我写了简单的测试代码，输出为:
C……
[/Quote]子进程完了后，应该通知父进程吧？是不是应该加以个通知？

[cumirror]

哈哈，谢谢LS。

[cumirror]

[Quote=引用 3 楼 qq120848369 的回复:]

C/C++ code
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/wait.h>

void alrmFunc(int signo)
{
printf("……
[/Quote]

关于管道的问题基本理解了。

不过对chldFunc()函数不是很清楚，子进程结束时，是由子进程还是父进响应这个函数啊？还是它们都会响应？

我目前感觉：子进程结束后，由父进程响应chldFunc函数，父进程最终是通过alarm函数中的exit退出。我改写了chldFunc中的打印信息，发现在while循环中循环了两次，第一次printf了子进程的pid，第二次waitpid返回<0的数值，然后跳出了while循环。
查看waitpid，如果有错误发生则返回-1，不知道这里的错误如何理解？

能再给一些意见吗，谢谢~

[qq120848369]

[Quote=引用 7 楼 cumirror 的回复:]

引用 3 楼 qq120848369 的回复:

C/C++ code
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/wait.h>

void alr……
[/Quote]

呵呵,孩子退出信号是发给父进程的,那个信号处理函数当然是写给父进程用的.

你没看到我在父进程里注册了那个信号么，子进程是没有注册的。

再其次，waitpid设置NOHANG的情况下如果当前没有孩子退出，那么返回0，相当于我们说的EAGAIN/EWOULDBLOCK。 如果返回-1，那么可能是EINTR，也就是被信号中断了，那么应该继续调用waitpid。
如果返回-1，也有可能是ECHILD，这个错误的意思是父进程已经没有孩子在运行了，所以不需要再waitpid了，