Understanding Goroutines

Go stands out for its ability to build competing applications simply and efficiently. One of the features that makes it this is Goroutines, one of the most powerful features of the language. If you've worked with other languages, you're probably familiar with threads, but Goroutines are different.

What are Goroutines?

In short, they are functions or methods that run concurrently with other functions or methods. They are lighter than OS threads, so you can create thousands of Goroutines with much less overhead.

What are Threads and why can Goroutines be lighter?

Threads are basically execution units within a process. A process can have multiple threads, all sharing the same memory space but with their own execution stack, which is basically a data structure that stores information about the active functions in a program. OS threads are managed and scaled by the OS, and also have a practical limit of thousands of threads per process and fixed stack size (generally 1MB or more per thread).

Goroutines are "green threads" or user-level threads, managed by the Go runtime, dynamic stack size starting at just 2KB and can expand or decrease according to need. That's why Goroutines can be lighter.

What is Competition and what is the difference from Parallelism?

Concurrency is the act of dealing with several tasks at the same time, while Parallelism executes tasks simultaneously on multiple processors. A bit confusing, but you'll understand better now: Competition involves more structure and organization. See the example below:

Parallelism involves more execution, actually running at the same time, see the example below:

What are Channels?

Channels are communication "channels" between Goroutines. They allow Goroutines to communicate and synchronize their execution. Example of communication between Goroutines using Channels:

func main() {
    ch := make(chan string)

    go func() {
        ch <- "Mensagem da goroutine"
    }()

    msg := <-ch
    fmt.Println(msg)
}

Now let's finish with examples of using Goroutines:

// 1. Fazendo café e torrada ao mesmo tempo
func cafeDaManha() {
   fmt.Println("Iniciando café da manhã...") // 1º: Aparece primeiro

   go fazerCafe()    // 2º: "Começando a fazer café..."
   go fazerTorrada() // 3º: "Começando a fazer torrada..."

   // Espera 5 segundos para tudo ficar pronto
   time.Sleep(5 * time.Second)
   fmt.Println("Café da manhã pronto!") // Último: Aparece depois de 5 segundos
}

func fazerCafe() {
   fmt.Println("Começando a fazer café...")
   time.Sleep(3 * time.Second) 
   fmt.Println("Café pronto!") // 4º: Aparece após 3 segundos
}

func fazerTorrada() {
   fmt.Println("Começando a fazer torrada...")
   time.Sleep(2 * time.Second)
   fmt.Println("Torrada pronta!") // 5º: Aparece após 2 segundos
}

/* Saída:
Iniciando café da manhã...
Começando a fazer café...
Começando a fazer torrada...
Torrada pronta! (após 2 segundos)
Café pronto! (após 3 segundos)
Café da manhã pronto! (após 5 segundos)
*/

// 2. Contagem com Goroutines
func contagem() {
   go contar("A", 5) // Começa a contar imediatamente
   go contar("B", 5) // Começa a contar imediatamente

   time.Sleep(6 * time.Second)
}

func contar(nome string, até int) {
   for i := 1; i <= até; i++ {
       fmt.Printf("%s: %d\n", nome, i)
       time.Sleep(1 * time.Second)
   }
}

/* Saída (aproximada - as linhas A e B se misturam):
A: 1
B: 1
A: 2
B: 2
A: 3
B: 3
A: 4
B: 4
A: 5
B: 5
*/

// 3. Enviando mensagens simples
func mensagens() {
   canal := make(chan string)

   go func() {
       canal <- "Olá!"      // 1ª mensagem enviada
       canal <- "Tudo bem?" // 2ª mensagem enviada
       canal <- "Tchau!"    // 3ª mensagem enviada
   }()

   fmt.Println(<-canal) // 1º: Imprime "Olá!"
   fmt.Println(<-canal) // 2º: Imprime "Tudo bem?"
   fmt.Println(<-canal) // 3º: Imprime "Tchau!"
}

/* Saída:
Olá!
Tudo bem?
Tchau!
*/

The above is the detailed content of Understanding Goroutines. For more information, please follow other related articles on the PHP Chinese website!