Go 子进程继承文件描述符数量不对怎么办

先确认你数的是 ExtraFiles 额外传入的文件，还是子进程全部打开的描述符。ExtraFiles 不包括标准输入、标准输出和标准错误；在支持的平台上，切片下标 i 对应子进程描述符 3+i，而不是父进程文件的 Fd() 数值。把父子双方的编号协议固定下来，再检查文件是否在启动前被关闭，通常比盯着描述符总数更有效。ExtraFiles 不支持 Windows。

Go 官方文档：https://pkg.go.dev/os/exec；文件对象说明：https://pkg.go.dev/os。本文只处理 ExtraFiles 索引与继承条件，不讨论 Windows 句柄传递或守护进程框架。

只传两份文件，不代表进程只会有五个描述符

最小映射可以写成：ExtraFiles = []*os.File{first, second}。first 在子进程中按 fd 3 使用，second 按 fd 4 使用。标准流通过 Cmd.Stdin、Cmd.Stdout、Cmd.Stderr 独立配置，不要把它们再塞进 ExtraFiles 后仍按“额外文件从零开始”读取。

操作系统和子程序自身也可能打开资源，检查目录的工具还可能带来额外观察对象。因此“总数不是 3+len(ExtraFiles)”不能单独证明继承失败。需要证明的是约定的编号是否可用，以及读到的对象是不是预期文件。

把切片位置当成父子双方的接口协议

父进程的 first.Fd() 可能是 7，也可能是其他值，它只是当前父进程中的编号。子进程不能直接沿用这个数字；它应读取约定的 3。增加、删除或调换 ExtraFiles 元素，会改变后续映射，应与子程序的读取约定一起修改。

如果传递数量是可变的，可以通过参数传入额外文件数量，但父子双方必须约定哪些下标各代表什么用途。不要根据父进程的最大 Fd() 猜测数量，也不要对切片盲目填充空位来迎合父端编号。本文示例使用两项非 nil 文件，避免把空槽位的语义混进排障。

准备、启动、关闭分别归谁负责

把文件赋给 ExtraFiles 只是准备配置，不是立即完成继承。父进程必须让文件在 Start 完成前保持有效，不可在启动前 Close，也不可让其他 goroutine 提前关闭或替换它。Start 成功后，如果父进程不再需要该文件，可以关闭父端这一份；子端的那一份由子进程关闭。关闭父端并不会代替子端关闭。

如果自行拆开 Start 和 Wait，只有 Start 成功才等待，并保证最终调用 Wait 回收进程相关资源。若 Start 失败，仍需由调用方清理自己打开的文件。为了让最小示例短而清楚，下面用 Run 包含启动和等待，让父端文件一直保留到 Run 返回；这比必要的持有时间长，但避免演示代码遗漏失败路径。

用同一个程序读取两个继承文件

将下列内容保存为 main.go，在 Linux 或 macOS 的普通命令行环境编译运行。程序创建两个临时文件，写入不同内容，恢复偏移，再直接启动自身的子模式。它不依赖外部 shell、不扫描其他进程，也不读取敏感文件。示例未在本文制作过程中执行，后面的输出说明是预期，不是实测记录。

package main

import (
    "fmt"
    "io"
    "os"
    "os/exec"
    "runtime"
)

func main() {
    if err := run(); err != nil {
        fmt.Fprintln(os.Stderr, err)
        os.Exit(1) // run 内的清理已完成，避免跳过 defer。
    }
}

func run() error {
    if runtime.GOOS == "windows" {
        return fmt.Errorf("此示例依赖 ExtraFiles，不支持 Windows")
    }
    if len(os.Args) == 2 && os.Args[1] == "--child" {
        for _, fd := range []uintptr{3, 4} {
            if err := readInherited(fd); err != nil {
                return err
            }
        }
        return nil
    }

    // 保存两份独立的文件对象；父进程负责关闭和删除临时文件。
    var files []*os.File
    defer func() {
        for _, f := range files {
            _ = f.Close() // 清理阶段尽力关闭，不覆盖主要错误。
            _ = os.Remove(f.Name())
        }
    }()
    for _, text := range []string{"alpha", "beta"} {
        f, err := os.CreateTemp("", "extra-files-demo-")
        if err != nil {
            return err
        }
        files = append(files, f)
        if _, err := io.WriteString(f, text); err != nil {
            return err
        }
        // 写入后恢复偏移，否则子进程可能从文件末尾开始读取。
        if _, err := f.Seek(0, io.SeekStart); err != nil {
            return err
        }
    }

    exe, err := os.Executable()
    if err != nil {
        return err
    }
    // 直接启动当前可执行文件，不让 shell 或包装脚本改变继承约定。
    cmd := exec.Command(exe, "--child")
    cmd.ExtraFiles = files // 下标 0 对应子进程 fd 3，下标 1 对应 fd 4。
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr
    // Run 包含启动和等待；此简例让父进程文件保持打开直到返回。
    if err := cmd.Run(); err != nil {
        return fmt.Errorf("子进程失败：%w", err)
    }
    return nil
}

func readInherited(fd uintptr) error {
    // NewFile 包装已有描述符，不会自动寻找或重新打开原始文件。
    f := os.NewFile(fd, fmt.Sprintf("inherited-%d", fd))
    if f == nil {
        return fmt.Errorf("无法包装 fd %d", fd)
    }
    data, readErr := io.ReadAll(f)
    closeErr := f.Close() // 关闭子进程这一份，不是父进程的文件对象。
    if readErr != nil {
        return fmt.Errorf("读取 fd %d：%w", fd, readErr)
    }
    if closeErr != nil {
        return closeErr
    }
    _, err := fmt.Printf("fd=%d 内容=%s\n", fd, data)
    return err
}

# 在保存 main.go 的目录编译为独立程序，再启动父模式。
go build -o extra-files-demo main.go
./extra-files-demo

预期子进程分别显示 fd=3 内容=alpha 与 fd=4 内容=beta，父进程正常退出。这个观察既确认编号，也确认文件身份；仅检查 NewFile 返回非 nil 不够，真正的读操作仍可能因无效描述符而失败。父进程返回时会关闭并删除它自己创建的临时文件，不删除其他路径。

看起来像少传文件，实际可能是这几种误判

读取为空：先看偏移。父端写入后没有 Seek 回起点，子端可能直接读到 EOF；这不是描述符数量减少。继承普通文件的描述符可能共享底层打开文件状态，不应假设父子具有独立读写位置。示例恢复位置后，父端不再继续读写这些文件。

经包装脚本后找不到 fd：直接子进程的继承约定不自动保证任意后代程序也保留同样编号。中间 shell、启动器或目标程序可能主动关闭、重定向文件。先用直接启动目标可执行文件的方式缩短观察范围，再按包装层的接口约定处理。

启动失败：先处理 Start 或 Run 返回的错误；未成功创建目标进程，就没有可讨论的目标继承结果。不要在同一个已使用的 Cmd 上重复启动，重新执行应构造新的 Cmd，并重新准备仍然有效的文件集合。

按现象选检查项，不按总数猜原因

ExtraFiles 会保留父进程原编号吗？

不会按父端 Fd() 数值传递这项协议。子端按切片下标加 3 使用描述符。

Run 会替我关闭 ExtraFiles 里的父端文件吗？

不要依赖它替调用方关闭这些自行打开的文件。父端明确负责自己的资源，子端明确关闭自己的包装对象。

父端关闭后，子端为什么还能读取？

启动成功后两边各有自己的描述符引用。关闭一个进程中的引用，不等于关闭另一个进程中的引用，但共享的底层状态仍需注意。

处理这类问题时，固定“下标、子端编号、文件身份、关闭责任”四项即可形成稳定检查路径。描述符总数可以作为线索，不能代替这四项契约。