all goroutines are asleep - deadlock

Question

For one of my requirement I have to create N number of worker go routines, which will be monitored by one monitoring routine. monitoring routine has to end when all worker routines completes. My code ending in deadlock, please help.

import "fmt"
import "sync"
import "strconv"

func worker(wg *sync.WaitGroup, cs chan string, i int ){
    defer wg.Done()
    cs<-"worker"+strconv.Itoa(i)    
}

func monitorWorker(wg *sync.WaitGroup, cs chan string) {
    defer wg.Done()
    for i:= range cs {
            fmt.Println(i)
     }
}
func main() {
    wg := &sync.WaitGroup{}
    cs := make(chan string)

    for i:=0;i<10;i++{
             wg.Add(1)
             go worker(wg,cs,i)
    } 

    wg.Add(1)
    go monitorWorker(wg,cs)
    wg.Wait()
}

Allow

Answer 1

Your monitorWorker never dies. When all the workers finish, it continues to wait on cs. This deadlocks because nothing else will ever send on cs and therefore wg will never reach 0. A possible fix is to have the monitor close the channel when all workers finish. If the for loop is in main, it will end the loop, return from main, and end the program.

For example: http://play.golang.org/p/nai7XtTMfr

package main

import (
    "fmt"
    "strconv"
    "sync"
)

func worker(wg *sync.WaitGroup, cs chan string, i int) {
    defer wg.Done()
    cs <- "worker" + strconv.Itoa(i)
}

func monitorWorker(wg *sync.WaitGroup, cs chan string) {
    wg.Wait()
    close(cs)
}

func main() {
    wg := &sync.WaitGroup{}
    cs := make(chan string)

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go worker(wg, cs, i)
    }

    go monitorWorker(wg, cs)

    for i := range cs {
        fmt.Println(i)

    }
}

---

Edit: This is an answer to OP's first comment.

Your program has three parts that need to synchronize. First, all of your workers need to send the data. Then your print loop needs to print that data. Then your main function needs to return thereby ending the program. In your example, all the workers send the data, all the data gets printed, but the message is never sent to main that it should return gracefully.

In my example, main does the printing and "monitorWorker" just tells main when it has received every piece of data it needs to print. This way the program ends gracefully and not by deadlock.

If you insist on the print loop being in another goroutine, you can do that. But then an extra communication needs to be sent to main so it returns. In this next example, I use a channel to ensure main ends when all data is printed.

package main

import (
    "fmt"
    "strconv"
    "sync"
)

func worker(wg *sync.WaitGroup, cs chan string, i int) {
    defer wg.Done()
    cs <- "worker" + strconv.Itoa(i)
}

func monitorWorker(wg *sync.WaitGroup, cs chan string) {
    wg.Wait()
    close(cs)
}

func printWorker(cs <-chan string, done chan<- bool) {
    for i := range cs {
        fmt.Println(i)
    }

    done <- true
}

func main() {
    wg := &sync.WaitGroup{}
    cs := make(chan string)

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go worker(wg, cs, i)
    }

    go monitorWorker(wg, cs)

    done := make(chan bool, 1)
    go printWorker(cs, done)
    <-done
}

Donitadonjon

Thanks for the help. But this does not solve my problem of parallel processing. In my case monitorWorker has to work parallely.(ie printing from channel). – Allow

@vrbilgi, I commented in the answer. – Donitadonjon

I tried different variations, But your answer is simple and elegant.thk:D – Allow

Answer 2

When I changed my channel definition from

strChan := make(chan string)

to

strChan := make(chan string, 1)

I was able to fix this error

Archives

It's much better to understand what this change does and why it stops the deadlock rather than make random changes. :-) – Antediluvian

Answer 3

If you know the count of the messages channel receives then simply you can limit your loop;

//c is channel
for a := 1; a <= 3; a++{
        fmt.Println(<-c)
}

Also you can pass another channel(status of the worker) to the worker then conditionally stop the loop that causes deadlock.

Ps: it's just an additional quick solution. Not specifically addresses your solution.

Merkley

Answer 4

it can be like this also , it will work

import "fmt"
import "sync"
import "strconv"

func worker(wg *sync.WaitGroup, cs chan string, i int) {
    defer wg.Done()
    cs <- "worker" + strconv.Itoa(i)

}

func monitorWorker(wg *sync.WaitGroup, cs chan string) {
    defer wg.Done()
    for i := range cs {
        fmt.Println(i)
    }
}
func main() {
    wg := &sync.WaitGroup{}

    cs := make(chan string, 10)

  go monitorWorker(wg, cs)
  
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go worker(wg, cs, i)
    }
    wg.Wait()
    close(cs)
}

Shuster