深入理解Go语言中select与default的调度陷阱及优化实践-Golang-PHP中文网

深入理解Go语言中select与default的调度陷阱及优化实践

本文探讨了Go语言中select语句结合default分支时可能导致的协程调度问题。当select在一个紧密循环中频繁执行default分支，且缺少调度点时，可能造成其他协程被“饿死”而程序无法终止。通过分析一个网络爬虫示例，我们揭示了fmt.Print意外充当调度点的现象，并提供了正确的循环结构以确保协程公平调度，避免程序无限挂起。

问题重现：select与default的调度困境

在go语言的并发编程中，select语句是处理多个通道操作的关键工具。然而，当select与default分支结合使用时，如果不理解其调度机制，可能会引入意想不到的问题。考虑一个简单的网络爬虫示例，其核心逻辑在一个无限循环中通过select语句处理待爬取任务和已完成任务：

package main

import (
    "fmt"
    "os"
    "time" // 引入time包用于模拟耗时操作或观察调度
)

type Fetcher interface {
    Fetch(url string) (body string, urls []string, err error)
}

func crawl(todo Todo, fetcher Fetcher,
    todoList chan Todo, done chan bool) {
    body, urls, err := fetcher.Fetch(todo.url)
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Printf("found: %s %q\n", todo.url, body)
        for _, u := range urls {
            todoList <- Todo{u, todo.depth - 1}
        }
    }
    done <- true
    return
}

type Todo struct {
    url   string
    depth int
}

func Crawl(url string, depth int, fetcher Fetcher) {
    visited := make(map[string]bool)
    doneCrawling := make(chan bool, 100)
    toDoList := make(chan Todo, 100)
    toDoList <- Todo{url, depth}

    crawling := 0
    for {
        select {
        case todo := <-toDoList:
            if todo.depth > 0 && !visited[todo.url] {
                crawling++
                visited[todo.url] = true
                go crawl(todo, fetcher, toDoList, doneCrawling)
            }
        case <-doneCrawling:
            crawling--
        default:
            // 这里的条件判断和fmt.Print是问题的核心
            if os.Args[1] == "ok" { // *
                fmt.Print("") // 这一行是关键差异
            }
            if crawling == 0 {
                goto END
            }
        }
    }
END:
    return
}

func main() {
    // 为了方便测试，main函数可能需要调整，这里保持原样
    // 实际运行时，os.Args[1]需要被提供
    // 比如：go run your_file.go ok 或 go run your_file.go nogood
    Crawl("http://golang.org/", 4, fetcher)
}

// 以下是模拟抓取器的代码，与问题无关，但为完整性保留
type fakeFetcher map[string]*fakeResult
type fakeResult struct {
    body string
    urls []string
}

func (f *fakeFetcher) Fetch(url string) (string, []string, error) {
    if res, ok := (*f)[url]; ok {
        return res.body, res.urls, nil
    }
    return "", nil, fmt.Errorf("not found: %s", url)
}

var fetcher = &fakeFetcher{
    "http://golang.org/": &fakeResult{
        "The Go Programming Language",
        []string{
            "http://golang.org/pkg/",
            "http://golang.org/cmd/",
        },
    },
    "http://golang.org/pkg/": &fakeResult{
        "Packages",
        []string{
            "http://golang.org/",
            "http://golang.org/cmd/",
            "http://golang.org/pkg/fmt/",
            "http://golang.org/pkg/os/",
        },
    },
    "http://golang.org/pkg/fmt/": &fakeResult{
        "Package fmt",
        []string{
            "http://golang.org/",
            "http://golang.org/pkg/",
        },
    },
    "http://golang.org/pkg/os/": &fakeResult{
        "Package os",
        []string{
            "http://golang.org/",
            "http://golang.org/pkg/",
        },
    },
}

登录后复制

当程序以go run your_file.go ok运行时，它能正常终止。但如果以go run your_file.go nogood运行，程序将无限挂起。唯一的区别在于select语句的default分支中是否包含fmt.Print("")。这表明一个看似无害的空打印语句，却意外地解决了程序的挂起问题。

原理剖析：协程调度与忙循环

Go语言的select语句行为分为两种情况：

不带default分支： select会阻塞当前协程，直到至少有一个通道操作可以执行。
带default分支： select不会阻塞。如果所有通道操作都不能立即执行，它会立即执行default分支。

在上述示例中，当toDoList和doneCrawling通道都没有数据时，select会立即进入default分支。如果crawling变量不为0，select会立即再次循环，不断地检查通道并进入default分支。

问题在于，在一个紧密的循环中频繁执行default分支，如果default分支内部没有显式的调度点（例如I/O操作、系统调用、或者某些Go运行时内部的函数调用），当前协程可能会长时间占据CPU，从而“饿死”其他需要运行的协程，尤其是那些负责向toDoList和doneCrawling发送数据的crawl协程。

立即学习“go语言免费学习笔记（深入）”；

fmt.Print("")虽然没有实际输出内容，但它涉及到底层I/O操作和系统调用，这些操作通常会触发Go调度器进行协程切换。因此，当fmt.Print("")存在时，它为调度器提供了一个将CPU时间分配给其他协程的机会，使得crawl协程能够运行，进而向通道发送数据，最终让主循环得以接收到数据并正常终止。

此外，这个现象也与GOMAXPROCS环境变量有关。如果将GOMAXPROCS设置为大于1的值（例如GOMAXPROCS=2 go run your_file.go nogood），即使没有fmt.Print("")，程序也可能正常终止。这是因为有多个操作系统线程可以执行Go协程，即使一个协程陷入忙循环，其他协程仍有机会在不同的OS线程上运行。但在GOMAXPROCS=1（Go 1.5版本之前默认值，之后默认是CPU核心数）的环境下，这个问题会更加突出。

解决方案：优化循环结构

为了避免这种调度陷阱，核心思想是确保主循环不会在通道没有准备好时陷入无限的忙等待。最直接的解决方案是将终止条件检查移到select语句之外，或者确保select在没有通道准备好时能够阻塞。

下面是修正后的Crawl函数，它将crawling == 0的判断移出了select的default分支，并移到了select之后：

百度文心百中

百度大模型语义搜索体验中心

查看详情

func Crawl(url string, depth int, fetcher Fetcher) {
    visited := make(map[string]bool)
    doneCrawling := make(chan bool, 100)
    toDoList := make(chan Todo, 100)
    toDoList <- Todo{url, depth}

    crawling := 0
    for {
        select {
        case todo := <-toDoList:
            if todo.depth > 0 && !visited[todo.url] {
                crawling++
                visited[todo.url] = true
                go crawl(todo, fetcher, toDoList, doneCrawling)
            }
        case <-doneCrawling:
            crawling--
        // 移除default分支，或仅在default中进行非关键操作
        // default:
        //  // 如果这里没有fmt.Print，且没有其他调度点，可能会导致饥饿
        //  // 更好的做法是让select阻塞，等待通道事件
        }
        // 将终止条件判断移到select之外
        if crawling == 0 {
            break // 使用break替代goto END
        }
    }
    return
}

登录后复制

在这个修正后的版本中，当toDoList和doneCrawling通道都没有数据时，select语句会阻塞，等待任何一个通道准备就绪。这种阻塞行为本身就是一个调度点，它允许Go调度器将CPU时间分配给其他crawl协程，让它们有机会完成任务并将结果发送到通道。一旦所有crawl协程都完成，crawling计数变为0，主循环将正常退出。

完整示例代码

以下是经过修正的完整爬虫代码，展示了如何正确处理select循环以避免调度问题：

package main

import (
    "fmt"
    "os" // os包在这里不再直接用于控制调度，但保留其用于示例参数
)

type Fetcher interface {
    Fetch(url string) (body string, urls []string, err error)
}

func crawl(todo Todo, fetcher Fetcher,
    todoList chan Todo, done chan bool) {
    body, urls, err := fetcher.Fetch(todo.url)
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Printf("found: %s %q\n", todo.url, body)
        for _, u := range urls {
            // 只有在深度允许且未访问过时才加入待办列表，避免无限循环和重复抓取
            // 这里假设visited检查在Crawl函数中处理
            todoList <- Todo{u, todo.depth - 1}
        }
    }
    done <- true
    return
}

type Todo struct {
    url   string
    depth int
}

// Crawl uses fetcher to recursively crawl
// pages starting with url, to a maximum of depth.
func Crawl(url string, depth int, fetcher Fetcher) {
    visited := make(map[string]bool)
    // doneCrawling通道的缓冲区大小应考虑同时运行的goroutine数量
    doneCrawling := make(chan bool, 100) 
    toDoList := make(chan Todo, 100)
    toDoList <- Todo{url, depth}

    crawling := 0
    for {
        select {
        case todo := <-toDoList:
            if todo.depth > 0 && !visited[todo.url] {
                crawling++
                visited[todo.url] = true
                go crawl(todo, fetcher, toDoList, doneCrawling)
            }
        case <-doneCrawling:
            crawling--
        }
        // 关键修正：将终止条件检查移到select外部
        // 这样当没有通道事件时，select会阻塞，允许其他goroutine运行
        if crawling == 0 {
            break // 使用break跳出循环
        }
    }
    return
}

func main() {
    // 运行示例时不再需要传递"ok"或"nogood"参数
    Crawl("http://golang.org/", 4, fetcher)
}

// fakeFetcher 和 fakeResult 保持不变
type fakeFetcher map[string]*fakeResult

type fakeResult struct {
    body string
    urls []string
}

func (f *fakeFetcher) Fetch(url string) (string, []string, error) {
    if res, ok := (*f)[url]; ok {
        return res.body, res.urls, nil
    }
    return "", nil, fmt.Errorf("not found: %s", url)
}

var fetcher = &fakeFetcher{
    "http://golang.org/": &fakeResult{
        "The Go Programming Language",
        []string{
            "http://golang.org/pkg/",
            "http://golang.org/cmd/",
        },
    },
    "http://golang.org/pkg/": &fakeResult{
        "Packages",
        []string{
            "http://golang.org/",
            "http://golang.org/cmd/",
            "http://golang.org/pkg/fmt/",
            "http://golang.org/pkg/os/",
        },
    },
    "http://golang.org/pkg/fmt/": &fakeResult{
        "Package fmt",
        []string{
            "http://golang.org/",
            "http://golang.org/pkg/",
        },
    },
    "http://golang.org/pkg/os/": &fakeResult{
        "Package os",
        []string{
            "http://golang.org/",
            "http://golang.org/pkg/",
        },
    },
}

登录后复制

注意事项与最佳实践

谨慎使用select的default分支： default分支使得select成为非阻塞的。在一个紧密循环中滥用default，而又没有显式或隐式的调度点，很容易导致协程忙等待，从而影响其他协程的调度。只有当确实需要非阻塞地尝试通道操作时才使用它。
确保协程中有合适的调度点： Go调度器会在某些操作（如通道操作、系统调用、I/O操作、time.Sleep等）时进行协程切换。如果一个协程执行计算密集型任务，长时间不进行这些操作，可以考虑使用runtime.Gosched()来主动让出CPU，给其他协程运行的机会。
避免在循环中进行忙等待： 尽量设计并发模式，使得协程在等待事件时能够阻塞，而不是通过default分支在一个紧密循环中不断检查。

使用sync.WaitGroup进行并发同步： 对于等待一组协程完成的场景，sync.WaitGroup通常是比手动管理crawling计数和doneCrawling通道更简洁和安全的做法。例如：

import "sync"

func CrawlWithWaitGroup(url string, depth int, fetcher Fetcher) {
    visited := make(map[string]bool)
    toDoList := make(chan Todo, 100)
    var wg sync.WaitGroup

    // 启动一个goroutine来处理待办列表
    go func() {
        toDoList <- Todo{url, depth}
    }()

    for todo := range toDoList {
        if todo.depth <= 0 || visited[todo.url] {
            // 如果深度不够或已访问，则不处理
            // 但需要确保所有wg.Add都被wg.Done匹配
            // 或者在主循环中显式处理退出
            continue
        }

        visited[todo.url] = true
        wg.Add(1) // 每启动一个爬取goroutine，计数器加1
        go func(t Todo) {
            defer wg.Done() // 爬取完成后，计数器减1
            body, urls, err := fetcher.Fetch(t.url)
            if err != nil {
                fmt.Println(err)
            } else {
                fmt.Printf("found: %s %q\n", t.url, body)
                for _, u := range urls {
                    select {
                    case toDoList <- Todo{u, t.depth - 1}:
                    // 成功发送到toDoList
                    default:
                        // 如果toDoList满了，可以考虑丢弃或采取其他策略
                        // 对于本例，toDoList有缓冲区，通常不会立即满
                        fmt.Printf("Warning: toDoList channel is full, dropping %s\n", u)
                    }
                }
            }
        }(todo)
    }
    // 等待所有爬取goroutine完成
    wg.Wait()
    close(toDoList) // 关闭通道，通知range循环结束
}

登录后复制

请注意，CrawlWithWaitGroup的实现比原始代码更复杂，需要仔细处理toDoList的关闭逻辑，以避免range toDoList的死锁。一个更鲁棒的WaitGroup实现通常会有一个单独的协调goroutine来管理toDoList的发送和关闭。然而，其核心思想是使用WaitGroup来跟踪正在运行的子协程数量，从而避免手动管理crawling计数和done通道。

总结

Go语言的并发模型强大而高效，但它要求开发者对协程调度和通道行为有清晰的理解。select语句与default分支的组合是一个常见的陷阱，可能导致协程饥饿和程序挂起。通过将终止条件判断移出select的default分支，或者采用sync.WaitGroup等更高级的并发原语，我们可以构建出健壮且高效的并发程序。理解Go调度器的工作原理，并确保在代码中提供足够的调度点，是编写高性能Go并发应用的关键。

以上就是深入理解Go语言中select与default的调度陷阱及优化实践的详细内容，更多请关注php中文网其它相关文章！