这是一个典型的Go并发编程中的goroutine调度和通道同步问题。问题的核心在于主goroutine在检查通道长度时，其他goroutine可能尚未被调度执行。

问题分析

在简化代码中，当移除runtime.Gosched()后，主goroutine会持续检查len(c)，但由于Go调度器可能没有机会切换到其他goroutine，导致：

1. rec()函数中的goroutine没有被执行
2. 通道c永远不会被填充
3. 主goroutine陷入无限循环

解决方案

使用正确的同步原语替代len(channel)检查。以下是修改后的简化代码：

package main

import (
    "fmt"
    "sync"
)

var (
    c  = make(chan struct{}, 1)
    wg sync.WaitGroup
)

func main() {
    rec(8)
    
    // 等待所有goroutine完成
    wg.Wait()
    
    // 清空通道
    for len(c) > 0 {
        <-c
    }
    
    fmt.Println("end")
}

func rec(count int) {
    if count == 0 {
        return
    }
    
    wg.Add(1)
    go func(cnt int) {
        defer wg.Done()
        
        c <- struct{}{}
        for i := 0; i < 5; i++ {
            go rec(cnt - 1)
        }
        <-c
    }(count)
}

原始代码的修复方案

对于原始代码，应该使用sync.WaitGroup来跟踪所有recTraverse goroutine的完成状态：

package main

import (
    "bufio"
    "fmt"
    "os"
    "runtime"
    "sync"
    "time"
)

var (
    countDir   = 0
    countFile  = 0
    countErr   = 0
    dirsPath   = `\dirsPath`
    filesPath  = `\filesPath`
    errsPath   = `\errsPath`
    chanFile   = make(chan string)
    chanDir    = make(chan string)
    chanErr    = make(chan string)
    writeClose = make(chan struct{})
    goMax      chan struct{}
    wg         sync.WaitGroup
)

func main() {
    goMax = make(chan struct{}, runtime.NumCPU()-1)
    date := time.Now().Format("20060102")
    go print()

    root := `C:\`
    pwd, _ := os.Getwd()
    go write(fmt.Sprintf("%s\\%s-%s.txt", pwd, dirsPath, date), 
             fmt.Sprintf("%s\\%s-%s.txt", pwd, filesPath, date), 
             fmt.Sprintf("%s\\%s-%s.txt", pwd, errsPath, date))

    wg.Add(1)
    go recTraverse(root)

    // 等待所有遍历goroutine完成
    wg.Wait()
    
    // 关闭输入通道
    close(chanDir)
    close(chanFile)
    close(chanErr)
    
    // 通知写入goroutine结束
    writeClose <- struct{}{}
    
    // 等待写入goroutine完成（如果需要）
    // time.Sleep(time.Millisecond * 100)

    fmt.Printf("执行完毕, 共记录文件 %d 个, 文件夹 %d 个, 错误 %d 条 \n", countFile, countDir, countErr)
}

func recTraverse(path string) {
    defer wg.Done()
    
    goMax <- struct{}{}
    defer func() { <-goMax }()
    
    entries, err := os.ReadDir(path)
    if err != nil {
        chanErr <- fmt.Sprintf("目录读取失败 %s ; 日志: %s ", path, err)
        return
    }
    
    for _, entry := range entries {
        if entry.IsDir() {
            newPath := path + entry.Name()
            chanDir <- newPath
            
            wg.Add(1)
            go recTraverse(newPath + `\`)
        } else {
            chanFile <- path + entry.Name()
        }
    }
}

func write(dirPath string, filePath string, errPath string) {
    dirFile, _ := os.Create(dirPath)
    fFile, _ := os.Create(filePath)
    errFile, _ := os.Create(errPath)
    
    defer dirFile.Close()
    defer fFile.Close()
    defer errFile.Close()
    
    dirWriter := bufio.NewWriter(dirFile)
    fileWriter := bufio.NewWriter(fFile)
    errWriter := bufio.NewWriter(errFile)
    
    defer dirWriter.Flush()
    defer fileWriter.Flush()
    defer errWriter.Flush()

    for {
        select {
        case data, ok := <-chanDir:
            if !ok {
                chanDir = nil
            } else {
                countDir++
                fmt.Fprintf(dirWriter, "%s\n", data)
            }
        case data, ok := <-chanFile:
            if !ok {
                chanFile = nil
            } else {
                countFile++
                fmt.Fprintf(fileWriter, "%s\n", data)
            }
        case data, ok := <-chanErr:
            if !ok {
                chanErr = nil
            } else {
                countErr++
                fmt.Fprintf(errWriter, "%s\n", data)
            }
        case <-writeClose:
            return
        }
        
        // 所有通道都关闭后退出
        if chanDir == nil && chanFile == nil && chanErr == nil {
            return
        }
    }
}

func print() {
    fmt.Printf("\n")
    start := time.Now()
    ticker := time.NewTicker(time.Millisecond)
    defer ticker.Stop()
    
    for {
        select {
        case <-ticker.C:
            elapsed := time.Since(start)
            fmt.Printf("运行时间: %.3f 秒 \r", elapsed.Seconds())
        case <-writeClose:
            elapsed := time.Since(start)
            fmt.Printf("运行时间: %.3f 秒 \n", elapsed.Seconds())
            return
        }
    }
}

关键改进点

1. 使用sync.WaitGroup替代通道长度检查：确保所有goroutine完成后再继续执行
2. 正确关闭通道：使用通道关闭状态检测而非len(channel)
3. 移除runtime.Gosched()：使用正确的同步原语，避免依赖调度器行为
4. 添加defer语句：确保资源正确释放和计数器递减

这种方案避免了竞态条件，不依赖于goroutine调度顺序，是Go并发编程中的标准做法。