func startChild(env *env, passedFiles map[fileName]*file) (*child, error) {
	// These pipes are used for communication between parent and child
	// readyW is passed to the child, readyR stays with the parent
    // readyW传递给子进程, 子进程启动且准备就绪后通过写readyW通知父进程
	readyR, readyW, err := os.Pipe() 
	// ...

    // 父进程向namesW写入文件描述符的信息(connKind, network, addr), 
    // 子进程会从namesR读取这些信息, 从而确定从父进程继承过来的文件描述符具体信息
	namesR, namesW, err := os.Pipe()    
	// ...

	// Copy passed fds and append the notification pipe
    // fds是需要继承给子进程的文件描述符, 前五个文件描述分别是:
    // 0~2: stdin, stdout, stderr,
    // 3(readW): 子进程准备就绪时通过此文件描述符通知父进程;
    // 4(nameR): 子进程从此文件描述符中读取文件描述符信息;
    // 5...: 需要子进程继承的文件描述符(一般是监听的socket)
	fds := []*os.File{os.Stdin, os.Stdout, os.Stderr, readyW, namesR}
	var fdNames [][]string
    // 注意: fdNames不包含0~4 5个描述符的信息(父子进程约定好了, 0~4文件描述符的作用是已知的)
	for name, file := range passedFiles {
		nameSlice := make([]string, len(name))
		copy(nameSlice, name[:])
		fdNames = append(fdNames, nameSlice)
		fds = append(fds, file.File)
	}

	// Copy environment and append the notification env vars
    // environ是要传递给子进程的环境变量, 特别添加了sentinelEnvVar环境变量
    // 设置sentinelEnvVar的作用是决定进程如何初始化文件描述符
	sentinel := fmt.Sprintf("%s=yes", sentinelEnvVar)
	var environ []string
	for _, val := range env.environ() {
		if val != sentinel {
			environ = append(environ, val)
		}
	}
	environ = append(environ, sentinel)

    // 这里调用newProc创建子进程, 传入了前面准备好的fds和environ
    // newProc会根据当前的平台(Linux or darwin)决定如何创建子进程
    // 对Linux而言, newProc的底层是fork+exec
	proc, err := env.newProc(os.Args[0], os.Args[1:], fds, environ)
	// ...

	exited := make(chan struct{})
	result := make(chan error, 1)
	ready := make(chan *os.File, 1)

	c := &child{
		env,
		proc,
		readyR,
		namesW,
		ready,
		result,
		exited,
	}

    // 通过pipe把子进程继承的文件描述符信息发送给子进程
	go c.writeNames(fdNames) 

    // 等待子进程结束的信号(正常情况下子进程不应该结束, 如果子进程在父进程之前结束, 说明子进程异常)
	go c.waitExit(result, exited)
    
    // 等待接收子进程发送过来的reay信号
	go c.waitReady(ready)
	return c, nil
}

// 等待子进程发送ready信号
func (c *child) waitReady(ready chan<- *os.File) {
	var b [1]byte
	if n, _ := c.readyR.Read(b[:]); n > 0 && b[0] == notifyReady {
		// We know that writeNames has exited by this point.
		// Closing the FD now signals to the child that the parent
		// has exited.
		ready <- c.namesW
	}
	c.readyR.Close()
}

// 父进程把文件描述符信息通过c.namesW管道传递给子进程
func (c *child) writeNames(names [][]string) {
	enc := gob.NewEncoder(c.namesW)
	if names == nil {
		// Gob panics on nil
		_ = enc.Encode([][]string{})
		return
	}
	_ = enc.Encode(names)
}

func newParent(env *env) (*parent, map[fileName]*file, error) {
    // 父进程在创建子进程时为子进程设置了sentinelEnvVar环境变量, 所以if不成立
	if env.getenv(sentinelEnvVar) == "" {
		return nil, make(map[fileName]*file), nil
	}

    // 根据child.go:startChild()可知:
    // 文件描述符3用于子进程ready后通知父进程
    // 文件描述符4用于子进程读取>=5的文件描述符的信息
	wr := env.newFile(3, "write")
	rd := env.newFile(4, "read")

	var names [][]string
    // 读取父进程传递的文件描述符信息
	dec := gob.NewDecoder(rd)
	if err := dec.Decode(&names); err != nil {
		return nil, nil, fmt.Errorf("can't decode names from parent process: %s", err)
	}

    // 把>=5的文件描述符(fd)和其信息(connKind, network, addr)关联起来
	files := make(map[fileName]*file)
	for i, parts := range names {
		var key fileName
		copy(key[:], parts)

		// Start at 5 to account for stdin, etc. and write
		// and read pipes.
		fd := 5 + i
		env.closeOnExec(fd)
		files[key] = &file{
			env.newFile(uintptr(fd), key.String()),
			uintptr(fd),
		}
	}

	result := make(chan error, 1)
	exited := make(chan struct{})
	go func() {
		defer rd.Close()

		n, err := io.Copy(ioutil.Discard, rd)
		if n != 0 {
			err = errors.New("unexpected data from parent process")
		} else if err != nil {
			err = fmt.Errorf("unexpected error while waiting for parent to exit: %s", err)
		}
		result <- err
		close(exited)
	}()

	return &parent{
		wr:     wr, // 记住, parent.wr用于通知父进程
		result: result,
		exited: exited,
	}, files, nil
}

// 调用Ready时, 如果parent存在, 则会调用sendReady
func (u *Upgrader) Ready() error {
	u.readyOnce.Do(func() {
		u.Fds.closeInherited()
		close(u.readyC)
	})

	if u.opts.PIDFile != "" {
		if err := writePIDFile(u.opts.PIDFile); err != nil {
			return fmt.Errorf("tableflip: can't write PID file: %s", err)
		}
	}

	if u.parent == nil {
		return nil
	}
    // 向父进程发送消息
	return u.parent.sendReady()
}

// 向parent.wr写入消息, 通知父进程
func (ps *parent) sendReady() error {
	defer ps.wr.Close()
	if _, err := ps.wr.Write([]byte{notifyReady}); err != nil {
		return fmt.Errorf("can't notify parent process: %s", err)
	}
	return nil
}