终止所有例程当一个例程失败时

从现在开始，我们要努力学习啦！今天我给大家带来《终止所有例程当一个例程失败时》，感兴趣的朋友请继续看下去吧！下文中的内容我们主要会涉及到等等知识点，如果在阅读本文过程中有遇到不清楚的地方，欢迎留言呀！我们一起讨论，一起学习！

我需要创建一个程序，该程序在不同的端口上启动多个服务器，并将每个工作程序启动到不同的队列。所有服务器和工作人员都在运行，或者如果至少一个服务器和工作人员出现故障，则应关闭其他服务

目前我正在监听一个频道，如果发生错误，只需执行 log.fatal ，它将执行 os.exit

• 这是在一个例程失败时终止所有例程且不会发生任何意外行为的正确方法吗？
• 这个问题有更好的解决方案吗？

我的简化程序如下所示：

package main

import (
    "log"
    "net/http"
)

func startWorker(queue string) error {
    // other logic which 
    // could return an 
    // error goes here
    
    // simulate worker work
    for {
        // get items from `queue`
        // and do something with it
        continue
    }
}

func startServer(port string) error {
    // other logic which 
    // could return an 
    // error goes here
    return http.ListenAndServe(port, nil)
}

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
    channel := make(chan error)

    go func() {
        channel <- startServer(":3000")
    }()

    go func() {
        channel <- startServer(":3001")
    }()

    go func() {
        channel <- startWorker("first")
    }()

    go func() {
        channel <- startWorker("second")
    }()

    if err := <-channel; err != nil {
        log.Fatal(err)
    }
}

正确答案

在我看来，os.exit() 和 log.fatal() 应该仅用于开发目的或极其意外的错误。

有一种方法可以优雅地处理服务器错误：

package main

import (
    "context"
    "fmt"
    "net/http"
    "time"
)

func startserver(server *http.server) error {
    // other logic which
    // could return an
    // error goes here
    return server.listenandserve()
}

func main() {
    http.handlefunc("/", func(w http.responsewriter, r *http.request) { w.writeheader(http.statusok) })

    server3000 := &http.server{addr: ":3000", handler: nil}
    server3001 := &http.server{addr: ":3001", handler: nil}

    closeall := func() {
        server3000.shutdown(context.background())
        server3001.shutdown(context.background())
    }

    go func() {
        err := startserver(server3000)
        fmt.printf("got error: %s\n", err)
        if err != nil {
            closeall()
        }
    }()

    go func() {
        err := startserver(server3001)
        fmt.printf("got error: %s\n", err)
        if err != nil {
            closeall()
        }
    }()

    timer := time.newtimer(time.second)
    <-timer.c
    server3000.close() // close one of the servers

    timer2 := time.newtimer(time.second)
    <-timer2.c // wait for both servers to shutdown
}

我省略了工作线程的关闭，因为这取决于它们的实现，但它们也可以在 closeall() 函数中处理。

希望这有助于

尝试在 goroutine 之间进行通信。它是 golang 并发的强大工具。 您可以向 goroutine 发送通道并更改等待，直到从任何 goroutine 发送错误。 我修复了您的代码，您在终端中看到“队列”，2 秒后应用程序因错误而停止。

package main

import (
    "errors"
    "fmt"
    "log"
    "net/http"
    "time"
)

func startWorker(queue string, ch chan error) error {
    // other logic which
    // could return an
    // error goes here

    // simulate worker work
    for {
        // get items from `queue`
        // and do something with it
        fmt.Println("queue")
        continue
    }
    return nil
}

func startServer(port string, ch chan error) error {
    // other logic which
    // could return an
    // error goes here
    if port == ":3000" {
        time.Sleep(2 * time.Second)
        ch <- errors.New("error")
    }

    return http.ListenAndServe(port, nil)
}

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
    channel := make(chan error)
    ch := make(chan error)

    go func() {
        channel <- startServer(":3000", ch)
    }()

    go func() {
        channel <- startServer(":3001", ch)
    }()

    go startWorker("first", ch)

    go startWorker("second", ch)

    if err := <-ch; err != nil {
        log.Fatal(err)
    }
}

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。