如何在 Go 例程中实现外循环的强制退出？

有志者，事竟成！如果你在学习Golang，那么本文《如何在 Go 例程中实现外循环的强制退出？》，就很适合你！文章讲解的知识点主要包括，若是你对本文感兴趣，或者是想搞懂其中某个知识点，就请你继续往下看吧~

这个想法是从 go 例程中退出外循环，我使用了一个通道来发出信号来打破循环。我使用信号量模式来限制生成的 goroutine 数量，这样，在等待循环退出时，我就不会生成大量的 go 例程。

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "sync"
)

type task struct {
    id        int    `json:"id"`
    userid    int    `json:"user_id"`
    title     string `json:"title"`
    completed bool   `json:"completed"`
}

func main() {
    var t task
    wg := &sync.waitgroup{}
    stop := make(chan struct{})
    sem := make(chan struct{}, 10)

    results := make(chan task, 1)

    worker := func(i int) {
        defer wg.done()
        defer func() { <-sem }()
        res, err := http.get(fmt.sprintf("https://jsonplaceholder.typicode.com/todos/%d", i))
        if err != nil {
            log.fatal(err)
        }
        defer res.body.close()
        if err := json.newdecoder(res.body).decode(&t); err != nil {
            log.fatal(err)
        }

        if i == 20 {
            close(stop)
        }
        results <- t
    }

    i := 0

outer:
    for {
        select {
        case <-stop:
            fmt.println("i came here")
            close(sem)
            break outer
        case v := <-results:
            fmt.println(v)
        default:
            wg.add(1)
            sem <- struct{}{}
            go worker(i)
            i++
        }
    }
    wg.wait()

    fmt.println("i am done")
}

现在的问题是，我看到它进入了我试图打破循环的情况，但它从未到达 我已经完成了 原因可能是它在尝试接收结果时被无限阻止。 我想知道如何有效地处理同样的问题。

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "sync"
)

type Task struct {
    ID        int    `json:"id"`
    UserID    int    `json:"user_id"`
    Title     string `json:"title"`
    Completed bool   `json:"completed"`
}

func main() {
    wg := &sync.WaitGroup{}

    sem := make(chan struct{}, 10)
    ctx, cancel := context.WithCancel(context.Background())
    var ts []Task
    //results := make(chan Task, 1)

    worker := func(i int) {
        var t Task
        defer wg.Done()
        defer func() {
            <-sem
        }()
        res, err := http.Get(fmt.Sprintf("https://jsonplaceholder.typicode.com/todos/%d", i))
        if err != nil {
            log.Fatal(err)
        }
        defer res.Body.Close()
        if err := json.NewDecoder(res.Body).Decode(&t); err != nil {
            log.Fatal(err)
        }

        if i > 20 {
            cancel()
        }
        ts = append(ts, t)
    }

    i := 0

outer:
    for {
        select {
        case <-ctx.Done():
            break outer
        default:
            wg.Add(1)
            sem <- struct{}{}
            go worker(i)
            i++
        }
    }
    wg.Wait()

    fmt.Println(ts)
}

这可行，但最终我在数组中得到了我想避免的重复条目。

编辑:: @davud 解决方案有效，但是，我仍然有兴趣知道如何进一步优化和限制生成的 goroutine 数量。当前生成的额外 goroutine = sem 的缓冲区大小。我想在保持并发的同时减少其中的数量。

正确答案

发生这种情况是因为一旦收到停止信号并退出 for 循环，您就不再侦听和打印结果，这会导致结果通道阻止工作线程继续处理。

作为解决方案，您可以在单独的 goroutine 中监听结果通道。

这里我删除了 case v := <-results: fmt.println(v) 并添加了一个 goroutine。尝试一下

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "sync"
)

type Task struct {
    ID        int    `json:"id"`
    UserID    int    `json:"user_id"`
    Title     string `json:"title"`
    Completed bool   `json:"completed"`
}

func main() {
    var t Task
    wg := &sync.WaitGroup{}
    stop := make(chan struct{})
    sem := make(chan struct{}, 10)

    results := make(chan Task, 1)

    worker := func(i int) {
        defer wg.Done()
        defer func() { <-sem }()
        res, err := http.Get(fmt.Sprintf("https://jsonplaceholder.typicode.com/todos/%d", i))
        if err != nil {
            log.Fatal(err)
        }
        defer res.Body.Close()
        if err := json.NewDecoder(res.Body).Decode(&t); err != nil {
            log.Fatal(err)
        }

        if i == 20 {
            close(stop)
        }
        results <- t
    }

    i := 0

    go func() {
        for v := range results {
            fmt.Println(v)
        }
    }()
outer:
    for {
        select {
        case <-stop:
            fmt.Println("I came here")
            close(sem)
            break outer
        default:
            wg.Add(1)
            sem <- struct{}{}
            go worker(i)
            i++
        }
    }
    wg.Wait()

    fmt.Println("I am done")
}

看来，第二个解决方案中的问题是，worker 共享 var t task。这意味着多个工作人员尝试为其分配一个值，但由于它只能保存一个值，因此工作人员在调用 append(ts, t) 之前会覆盖彼此的值。如果 append 最终由不同的工作线程调用，则分配给 t 的最后一个值将多次附加到 ts。工作人员调用 append，而 t 不再保留其值，因此会出现重复项。这是一个数据竞争/竞争条件。

解决方案：将 var t task 移至工作线程内，使其不再共享。

以上就是《如何在 Go 例程中实现外循环的强制退出？》的详细内容，更多关于的资料请关注golang学习网公众号！