Resolvendo impasse de Goroutines

Neste cenário, você encontrou um erro de impasse em seu código de simultaneidade Go. Vamos nos aprofundar no assunto e apresentar uma solução eficiente.

O erro ocorre devido ao descompasso entre o comportamento de seus produtores e do consumidor. Seus produtores, implementados na função de produtor, estão enviando valores no canal ch por um período limitado. Porém, o consumidor, presente em sua função principal, corre indefinidamente, tentando incessantemente receber valores do ch.

Para resolver esse impasse, é preciso garantir que o consumidor respeite o preenchimento dos produtores. Isso significa que o consumidor deve encerrar automaticamente quando os produtores terminarem de enviar os valores.

Uma abordagem eficaz é utilizar um sync.WaitGroup para coordenar os produtores. O grupo de espera permite acompanhar o andamento dos produtores e esperar que eles concluam suas tarefas antes de fechar o canal. Aqui está uma versão melhorada do seu código:

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)
    }
}

Neste código atualizado, o sync.WaitGroup é usado para controlar o número de produtores ativos. Os produtores chamam wg.Done() para diminuir o grupo de espera quando terminam de enviar valores. A goroutine principal espera que todos os produtores terminem usando wg.Wait() e, em seguida, fecha o canal ch.

Ao utilizar um sync.WaitGroup, você estabelece um mecanismo de coordenação que permite ao seu consumidor respeitar o status de conclusão dos produtores, resolvendo efetivamente o erro de impasse.