Como o Go lida com as goroutines de tempo limite?

Pergunta:

Você está criando uma ferramenta que lida com várias chamadas HTTP em goroutines simultâneas. Para evitar um cenário de execução indefinida, você procura uma maneira de cancelar as goroutines após um lapso de tempo específico.

Solução:

Enquanto a abordagem de criar uma goroutine para dormir por um período especificado e enviar uma mensagem de transmissão para cancelar as outras goroutines parece lógico, parece haver um problema com a execução de goroutines neste cenário.

Para resolver isso desafio, considere aproveitar o pacote de contexto em Go. Ele oferece uma maneira eficaz de lidar com tempos limite e cancelamento de contexto para goroutines.

Snippet de código:

Aqui está um exemplo usando o pacote de contexto para gerenciamento de tempo limite de goroutines:

package main

import (
    "context"
    "fmt"
    "time"
)

func test(ctx context.Context) {
    t := time.Now()

    select {
    case <-time.After(1 * time.Second):
        fmt.Println("overslept")
    case <-ctx.Done():
        fmt.Println("cancelled")
    }
    fmt.Println("used:", time.Since(t))
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)

    go test(ctx)

    // cancel context after 30 milliseconds
    time.Sleep(30 * time.Millisecond)
    cancel()
}

Este código cria um contexto com um tempo limite de 50 milissegundos. Uma goroutine é então lançada para executar a função de teste, passando o contexto. Dentro da função de teste, uma instrução select aguarda que o tempo limite ocorra ou que o contexto seja cancelado. Após 30 milissegundos, o contexto é cancelado, fazendo com que a goroutine termine e imprima "cancelado".