Warum schreibt mein Golang-Kanal immer für immer?

Question

Ich habe in den letzten Tagen versucht, einen Wechsel bei der Parallelität in Golang zu machen, indem ich eines meiner Kommandozeilenprogramme umgestaltet habe, aber ich stecke fest.

Here's der ursprüngliche Code (Master-Zweig).

Here's der Zweig mit Nebenläufigkeit (Zweig x_concurrent).

Wenn ich den gleichzeitigen Code mit go run jira_open_comment_emailer.go ausführen, führt die defer wg.Done() nie, wenn die JIRA Frage zum here Kanal hinzugefügt wird, die meine wg.Wait() verursacht immer hängen.

Die Idee ist, dass ich eine große Anzahl von JIRA-Problemen habe, und ich möchte für jedes eine Goroutine ausgliedern, um zu sehen, ob es einen Kommentar hat, auf den ich antworten muss. Wenn dies der Fall ist, möchte ich es zu einer Struktur hinzufügen (ich habe nach einigen Nachforschungen einen Kanal gewählt), die ich später aus einer Warteschlange lesen kann, um eine Erinnerung per E-Mail zu erstellen.

Hier ist der entsprechende Abschnitt des Codes:

// Given an issue, determine if it has an open comment 
// Returns true if there is an open comment on the issue, otherwise false 
func getAndProcessComments(issue Issue, channel chan<- Issue, wg *sync.WaitGroup) { 
    // Decrement the wait counter when the function returns 
    defer wg.Done() 

    needsReply := false 

    // Loop over the comments in the issue 
    for _, comment := range issue.Fields.Comment.Comments { 
     commentMatched, err := regexp.MatchString("~"+config.JIRAUsername, comment.Body) 
     checkError("Failed to regex match against comment body", err) 

     if commentMatched { 
      needsReply = true 
     } 

     if comment.Author.Name == config.JIRAUsername { 
      needsReply = false 
     } 
    } 

    // Only add the issue to the channel if it needs a reply 
    if needsReply == true { 
     // This never allows the defered wg.Done() to execute? 
     channel <- issue 
    } 
} 

func main() { 
    start := time.Now() 

    // This retrieves all issues in a search from JIRA 
    allIssues := getFullIssueList() 

    // Initialize a wait group 
    var wg sync.WaitGroup 

    // Set the number of waits to the number of issues to process 
    wg.Add(len(allIssues)) 

    // Create a channel to store issues that need a reply 
    channel := make(chan Issue) 

    for _, issue := range allIssues { 
     go getAndProcessComments(issue, channel, &wg) 
    } 

    // Block until all of my goroutines have processed their issues. 
    wg.Wait() 

    // Only send an email if the channel has one or more issues 
    if len(channel) > 0 { 
     sendEmail(channel) 
    } 

    fmt.Printf("Script ran in %s", time.Since(start)) 
} 

Answer 1

Die goroutines zum ungepufferte Kanal zum Senden blockieren. eine minimale Änderung der goroutines entblockt ist eine gepufferte Kanal mit einer Kapazität für alle Probleme zu schaffen:

channel := make(chan Issue, len(allIssues)) 

und den Kanal nach dem Aufruf von wg.Wait() schließen.