如何检查 stdout 是否已关闭 - 而不向其写入数据？

IT行业相对于一般传统行业，发展更新速度更快，一旦停止了学习，很快就会被行业所淘汰。所以我们需要踏踏实实的不断学习，精进自己的技术，尤其是初学者。今天编程网给大家整理了《如何检查 stdout 是否已关闭 - 而不向其写入数据？》，聊聊，我们一起来看看吧！

我编写了一个程序，用于读取数据、过滤和处理数据并将其写入标准输出。如果 stdout 通过管道传输到另一个进程，并且管道进程终止，我会收到 sigpiped，这很棒，因为程序终止，管道及时结束。

然而，根据过滤器参数，可能有几十秒没有一次写入，并且在这段时间内不会有sigpipe，尽管下游进程早已完成。如何在不实际向标准输出写入内容的情况下检测到这一点？目前，管道只是挂起，直到我的程序因自然原因终止。

我尝试编写一个零长度切片

if _, err := os.Stdout.Write([]byte{}); err != nil

但不幸的是，这不会导致错误。

注意理想情况下，无论平台如何，这都应该有效，但如果它仅在 linux 上工作，那就已经是一个改进。

解决方案

这并不能在 Go 中回答这个问题，但你可能会找到一种使用它的方法。 如果您可以将 poll(2) 应用于管道的写入端，那么当管道变得不可写时，您将收到通知。如何将其集成到您的 go 代码中取决于您的程序；希望它有用：

#include <errno.h>
#include <poll.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

void sp(int sno) {
    write(2, "sigpipe!\n", 9);
    _exit(1);
}

int waitfd(int fd) {
    int n;
    struct pollfd p;
    p.fd = fd;
    p.events = pollout | pollrdband;
    
    p.revents = 0;
    if ((n=poll(&p, 1, -1)) == 1) {
        if (p.revents & pollout) {
            return fd;
        }
        if (p.revents & (pollerr|pollhup)) {
            return -1;
        }
    }
    fprintf(stderr, "poll=%d (%d:%s), r=%#x\n",
        n, errno, strerror(errno), p.revents);
    return -1;
}

int main() {
    int count = 0;
    char c;
    signal(sigpipe, sp);
    while (read(0, &c, 1) > 0) {
        int w;
        while ((w=waitfd(1)) != -1 &&
            write(1, &c, 1) != 1) {
        }
        if (w == -1) {
            break;
        }
        count++;
    }
    fprintf(stderr, "wrote %d\n", count);
    return 0;
}

在 linux 中，您可以运行此程序： ./a.out < /dev/zero | sleep 1 ，它会打印类似：wrote 61441。你可以把它改为睡眠3秒，它会打印同样的东西。这是很好的证据，表明它已经填满了管道，正在等待空间。 sleep 永远不会从管道中读取数据，因此当其时间到时，它会关闭读取端，从而通过 pollerr 事件唤醒 poll(2)。

如果您将 poll 事件更改为不包含 pollout，您将得到更简单的程序：

#include <errno.h>
#include <fcntl.h>
#include <poll.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

int waitfd(int fd) {
    int n;
    struct pollfd p;
    p.fd = fd;
    p.events = pollrdband;
    p.revents = 0;
    if ((n=poll(&p, 1, -1)) == 1) {
        if (p.revents & (pollerr|pollhup)) {
            return -1;
        }
    }
    fprintf(stderr, "poll=%d (%d:%s), r=%#x\n",
        n, errno, strerror(errno), p.revents);
    return -1;
}

int main() {
    if (waitfd(1) == -1) {
        fprintf(stderr, "got an error!\n");
    }
    return 0;
}

其中“出现错误！”表明管道已关闭。我不知道这有多便携，因为 poll(2) 文档有点粗略。 如果没有 pollrdband（因此 events 为 0），这可以在 linux 上运行，但不能在 unix 上运行（至少在 solaris 和 Macos 上）。同样，文档毫无用处，但是拥有内核源代码可以回答许多问题:)

这个例子，使用线程，可以直接映射到go：

#include <pthread.h>
#include <errno.h>
#include <poll.h>
#include <signal.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

int events = pollrdband;

void sp(int sno) {
    char buf[64];
    write(2, buf, snprintf(buf, sizeof buf, "%d: sig%s(%d)\n", getpid(), sys_siglist[sno], sno));
    _exit(1);
}

int waitfd(int fd) {
    int n;
    struct pollfd p;
    p.fd = fd;
    p.events = events;
    
    p.revents = 0;
    if ((n=poll(&p, 1, -1)) == 1) {
        if (p.revents & (pollerr|pollhup)) {
            return -1;
        }
        return fd;
    }
    return -1;
}

void *waitpipe(void *t) {
    int x = (int)(intptr_t)t; 
    waitfd(x);
    kill(getpid(), sigusr1);
    return null;
}

int main(int ac) {
    pthread_t killer;
    int count = 0;
    char c;
    
    events |= (ac > 1) ? pollout : 0;

    signal(sigpipe, sp);
    signal(sigusr1, sp);

    pthread_create(&killer, 0, waitpipe, (int *)1);
    while (read(0, &c, 1) > 0) {
        write(1, &c, 1);
        count++;
    }
    fprintf(stderr, "wrote %d\n", count);
    return 0;
}

请注意，它在轮询上停放一个线程，并生成一个 sigusr1。这是运行它：

mcloud:pipe $ ./spthr < /dev/zero | hexdump -n80
0000000 0000 0000 0000 0000 0000 0000 0000 0000
*
0000050
185965: sigUser defined signal 1(10)
mcloud:pipe $ ./spthr < /dev/zero | sleep 1
185969: sigUser defined signal 1(10)
mcloud:pipe $ ./spthr | sleep 1
185972: sigUser defined signal 1(10)
mcloud:pipe $ ./spthr < /dev/zero | hexdump -n800000
0000000 0000 0000 0000 0000 0000 0000 0000 0000
*
00c3500
185976: sigBroken pipe(13)

在第一个命令中，hexdump 在 80 个字节后退出，轮询从根本上与读+写循环竞争，因此它可能生成 sigpipe 或 sigusr1。

后两个演示当管道读取器退出时，无论管道的写入端是否已满，sleep 都会导致 sigusr1（轮询返回异常事件）。

第四种，使用 hexdump 读取大量数据，远远超过管道容量，这更确定性地导致 sigpipe。

您可以生成更准确地建模的测试程序，但要点是管道关闭后程序会立即收到通知；不必等到下一次写入。

到这里，我们也就讲完了《如何检查 stdout 是否已关闭 - 而不向其写入数据？》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注编程网公众号，带你了解更多关于的知识点！