Uma das características mais marcantes de Go é a capacidade de criar goroutines, que são "threads leves" que podem ser executadas concorrentemente. Neste artigo, vamos explorar como criar uma goroutine em Go e alguns conceitos.

Conceito de Goroutine

Diferente das threads tradicionais, as goroutines são executadas em um único sistema operacional (OS) thread, mas a linguagem cuida da atribuição e do agendamento de tarefas, permitindo que múltiplas goroutines sejam executadas concorrentemente. Isso torna a concorrência em Go mais eficiente e fácil de usar. Principalmente comparado a outras linguagens.

Uma goroutine é uma função que pode ser executada de forma concorrente com outras goroutines dentro de um programa Go.

Elas são leves em termos de recursos, permitindo que você crie milhares ou até mesmo milhões delas. As goroutines são a base da concorrência em Go e oferecem uma maneira eficiente de trabalhar com concorrência na linguagem.

Acho que não preciso dizer que concorrência é diferente de paralelismo. Afinal, já temos muitos conteúdos que falam sobre isso, e até mesmo o próprio Rob Pike fez uma talk sobre Concurrency is not parallelism.

Então partindo da premissa que você já sabe sobre essa diferença, vamos ao foco desse mini artigo.

Criando uma Gorountine

Em Go, a criação de uma goroutine é extremamente simples. Basta prefixar uma função com a palavra-chave go para indicar que ela será executada como uma goroutine. Por exemplo:

package main

import (
    "fmt"
    "time"
)

func minhaGoroutine() {
    fmt.Println("Minha goroutine está em execução!")
    time.Sleep(time.Second)
    fmt.Println("Minha goroutine está concluída!")
}

func main() {
    go minhaGoroutine()
    fmt.Println("Função main está em execução!")

    time.Sleep(2 * time.Second)
}

Neste exemplo, a função minhaGoroutine() é executada como uma goroutine. Ela imprime uma mensagem, aguarda um segundo e, em seguida, imprime outra mensagem. A função main() chama a minhaGoroutine() como uma goroutine e continua a executar o restante do código. Para garantir que a goroutine tenha tempo suficiente para ser executada, usamos time.Sleep() para pausar a execução da função main().

Rob Pike, um dos criadores de Go, enfatiza a importância das goroutines em sua apresentação "Concurrency Is Not Parallelism" (Concorrência não é Paralelismo). Ele destaca que as goroutines fornecem um modelo de programação simples e eficiente para lidar com a concorrência. Ele afirma que "a concorrência é uma forma de estruturação de programas, não apenas uma forma de paralelismo" e destaca como as goroutines facilitam a composição de tarefas concorrentes.

A criação de goroutines em Go permite uma programação concorrente eficiente e elegante. Com a inspiração de Rob Pike e outros criadores da linguagem, as goroutines se tornaram uma parte fundamental da filosofia de Go.

Então... aproveite o poder da concorrência em Go e explore as possibilidades oferecidas pelas goroutines para criar programas robustos e eficientes. Lembre-se sempre de considerar a segurança e sincronização ao lidar com múltiplas goroutines.

Até a proximo!