我正在用 Go 创建一个电子邮件发送应用程序。

我遇到了无法成功发送电子邮件的问题。在这些情况下，我想在 go channel 中返回电子邮件，但该 channel 已关闭。

如何防止 channel 在所有任务完成之前关闭？

这是有这个问题的函数:

func worker(toSend chan combo, tried chan combo, s smptInfo, wg *sync.WaitGroup) {
    for try := range toSend {

        startSend := time.Now()
        delegate := make(chan bool, 1)
        go sendEmailSSH(try, delegate, s, try.line)
        select {
        case res := <-delegate:
            if res == true {
                try.success = res
                tried <- try
            } else {
                toSend <- try // if send not successfull return back to channel
            }
        case <-time.After(smtpTimeout):
            toSend <- try // if send timeout return back to channel
        }

        Pauza(startSend) // if send more fast like limit send, wait.
    }

    wg.Done()
}

可以在 GitHub 上找到完整的应用程序.

最佳答案

这是我建议的方法。为简单起见，我删除了几个 SMTP 特定部分。您可以重新插入它们。

<强>1。示例代码:

package main

import (
    "fmt"
    "log"
    "math/rand"
    "sync"
    "time"
)

type combo struct {
    success bool
    toEmail string
}

func sendEmailSSH(try combo, delegate chan bool) {

    defer close(delegate)

    r := rand.Intn(7)
    time.Sleep(time.Duration(r) * time.Second)
    if r%2 == 0 {
        fmt.Printf("sendEmailSSH: failing randomly after %d seconds: %+v\n", r, try)

        delegate <- false
    } else {
        fmt.Printf("sendEmailSSH: successful after %d seconds: %+v\n", r, try)

        delegate <- true

    }

}

func sendEmailSSHWrapper(try combo, toRetry chan combo) {

    // do something with try
    delegate := make(chan bool, 1)
    smtpTimeout := 3 // if no success within 3 seconds, mark it as failed

    go sendEmailSSH(try, delegate)


    go func() {
                select {
        case res := <-delegate:
            if res == true {
                try.success = res
            } else {
                toRetry <- try // if send not successfull, add to retry channel
            }
        case <-time.After(time.Duration(smtpTimeout) * time.Second):
            fmt.Printf("sendEmailSSHWrapper: failing due to timeout: %+v\n", try)

            toRetry <- try // if send timeout, add to retry channel
        }

    }()

}

// where we actually do the work
func worker(toSend chan combo, wg *sync.WaitGroup, id int) {

    toRetry := make(chan combo, 5)
    retryDone := false

    for try := range toSend {
        go sendEmailSSHWrapper(try, toRetry)
    }

    for !retryDone {
        select {

        case try, ok := <-toRetry:
            if !ok {
                log.Println("toRetry is already closed")
                retryDone = true
                continue
            }
            fmt.Printf("worker %d: picking up %+v for retry\n", id, try)
            go sendEmailSSHWrapper(try, toRetry)
        case <-time.After(time.Duration(15) * time.Second):
            fmt.Printf("worker %d: no data in toRetry(%d) channel for 15 seconds. closing toRetry now\n", id, id)
            close(toRetry)
            toRetry = nil
            retryDone = true
        }

    }

    wg.Done()
}

func main() {

    var wg sync.WaitGroup // keep track of the workers

    toSend := make(chan combo) // to the workers

    // emailList := []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"}
    emailList := []string{"a", "b", "c", "d", "e", "f"}


    // initialize n workers

    for i := 0; i < 5; i++ {
        wg.Add(1)
        go worker(toSend, &wg, i)
    }

    var count int = 0

    for i := 0; i < len(emailList); i++ {
        count++
        toSend <- combo{toEmail: emailList[i], success: false}
    }

    close(toSend)
    wg.Wait()

    fmt.Println("Send emails Done!")
}

在这里试试: https://play.golang.org/p/W7ur2wr3HeD

<强>2。我做了什么:

1. 只要 main 添加完数据，它就应该关闭 toSend channel 。它不会再被使用。
2. 为 sendEmailSSH 函数创建一个包装器。您当前调用 go sendEmailSSH(try, delegate, s, try.line) 的实现不是很优化，因为在启动 go 例程后，它无论如何都会在一元大小的 channel 上被阻塞，就像适合连续通话。
3. 或者，我调用了 go sendEmailSSHWrapper(try, toRetry)，它在内部调用实际的 sendEmailSSHWrapper 函数并监控委托(delegate) channel 。
4. sendEmailSSH 随机失败一些请求，用于演示目的。
5. sendEmailSSHWrapper 监控 delegate 它自己的失败 channel ，并检查超时(我将其保留 3 秒用于演示)
6. Worker 首先完全耗尽 toSend channel 。然后移动到 toRetry channel 。它可以正常工作，除非它在 ​​15 秒内在此 channel 上没有看到任何数据(再次保持高电平以进行演示)

<强>3。您需要添加的内容:

1. 您确实应该实现某种机制，以便您对任何给定的电子邮件地址仅重试给定的次数。否则，对于任何错误的电子邮件地址或任何意外情况(由于延迟导致多次连续超时)，您可能会永远陷入 for 循环，可能会使用映射来跟踪重试条目的计数。或者更简单，将 retryCount int 添加到您的 combo 结构，并在每次重试时递增它，并在每次重试之前进行检查。

2. 请注意，在您和我的方法中，我们都会在超时时重试。您确定如果发生超时，将永远不会发送电子邮件吗？如果没有，您真的应该使用 context with cancellation，或者如果需要更多时间，则以某种方式终止实际的 go 例程，然后再重试。否则，在某个糟糕的日子，如果延迟时间更长，您可能会超时很多，然后继续重试。而实际上，您会向用户发送大量电子邮件垃圾邮件。

关于go - 如何等待所有工作完成再关闭 channel ？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/52265146/