Solving Goroutines Deadlock

In this scenario, you have encountered a deadlock error in your Go concurrency code. Let's delve into the issue and provide an efficient solution.

The error occurs due to the mismatch between the behavior of your producers and consumer. Your producers, implemented in the producer function, are sending values on the channel ch for a limited duration. However, the consumer, present in your main function, runs indefinitely, endlessly attempting to receive values from ch.

To resolve this deadlock, you need to ensure that the consumer respects the completion of the producers. This means that the consumer should terminate automatically when the producers have finished sending values.

One effective approach is to utilize a sync.WaitGroup to coordinate the producers. The wait group allows you to track the progress of the producers and wait for them to complete their tasks before closing the channel. Here's an improved version of your code:

func main() {
    var wg sync.WaitGroup
    ch := make(chan int)

    wg.Add(1)
    go producer(ch, 100*time.Millisecond, 2, &wg)

    wg.Add(1)
    go producer(ch, 200*time.Millisecond, 5, &wg)

    // Start a goroutine to close the channel when all producers are done
    go func() {
        wg.Wait()
        close(ch)
    }()

    // Use a for range loop to receive values from the channel
    for v := range ch {
        fmt.Println(v)
    }
}

In this updated code, the sync.WaitGroup is used to keep track of the number of active producers. The producers call wg.Done() to decrement the wait group when they finish sending values. The main goroutine waits for all producers to finish using wg.Wait(), and then closes the ch channel.

By utilizing a sync.WaitGroup, you establish a coordination mechanism that allows your consumer to respect the completion status of the producers, effectively resolving the deadlock error.