Go: Processos e Concorrência
Afluentes: Sistemas Distribuídos e Mobile
Concorrência
|
A linguagem de programação Go trabalha com concorrência usando as gorotines. Elas exencutam funções paralelamente. É mais ou menos o conceito de threads, mas são mais leves, pois o custo da criação de gorotines é menor do que se comparado a uma thread.
- Vantagens das Gorotines
- Mais leves computacionamente, ocupando menos memória na pilha e a pilha pode alterar seu tamanho conforme a necessidade da aplicação. As threads possuem tamanho de pilha fixo;
- As gorotines são multiplexadas para um número menor de threads do Sistema Operacional. Ou seja, pode haver uma única thread no programa com várias gorotines executando. Caso uma thread seja bloqueada por uma goritne, as outras gorotines que estão nela podem ser movidas para outra thread;
- Goroutines se comunicam por meio de
canais, que previnem que race conditions aconteçam ao acessar memória compartilhada.
Para chamar uma função de forma concorrente no Go, basta chamá-la com a palavra chave go na frente:
package main
import (
"fmt"
)
func hello() {
fmt.Println("Hello world goroutine")
}
func main() {
go hello()
// Vamos dar uma pausa aqui senão o programa pode terminar
// antes de executar a gorotine
time.Sleep(1 * time.Second)
fmt.Println("main function")
}
Subprocessos
Estou falando em subprocessos, mas estamos implementando gorotines na linguagem go.
Veja que no exemplo, vamos criar uma gorotine que será filha do processo principal. Nas duas execuções, colocamos algumas linhas de execução e um pequeno delay aleatório.
O problema é que caso o programa termine sem ter terminado a gorotine chamada por ele, ela fecha também. Para contornar esse problema, vamos usar um sistema de sincronização via WAIT.
A gente cria uma variável que será um objeto do tipo sync.WaitGroup e para cada gorotine instanciada, a gente faz um incremento no objeto.
var wg sync.WaitGroup
wg.Add(1)
go child(&wg) // child é nossa função para paralelizar
De dentro da função child, que irá executar em paralelo, a gente já de início dá um defer para executar um Done no objeto WaitGroup. Cada done feito no objeto, é decrementado em um uma variável interna que controla a quantidade de gorotines executando.
defer wg.Done()
Não podemos esquecer que vamos ter que passar o objeto do WaitGroup como parâmetro de referência, então nossa função tem que estar preparada pra isso.
func child(wg *sync.WaitGroup) { //...
Ao final do programa principal, a gente usa um WAIT para agardar até que a gorotine tenha terminado.
wg.Wait()
Para só então dar sequência e fechar o programa.
package main
import (
"fmt"
"math/rand"
"sync"
"time"
)
func child(wg *sync.WaitGroup) {
defer wg.Done() // decrementa o contador de processo
fmt.Println("Luke: Noooooo.....") // imprime na tela
for i := 0; i < 5; i++ { // executa o laço 5 vezes
fmt.Println("Luke: No!") // imprime n a tela
d := rand.Intn(2000) // retorna um número randômico de 0 a 1999
time.Sleep(time.Duration(d) * time.Millisecond) // aguarda um tempo
}
fmt.Println("Luke Skywalker falls.") // imprime na tela
}
func main() {
var wg sync.WaitGroup // wg é tilizado para sincronizar os processos
wg.Add(1) // incrementa o contador de processos
go child(&wg) // chama a rotina child paralelamente
fmt.Println("Vader: Luke! I am your father...") // imprime na tela
for i := 0; i < 5; i++ { // executa o laço 5 vezes
fmt.Println("Vader: Yes!") // imprime na tela
d := rand.Intn(2000) // retorna um número randômico de 0 a 1999
time.Sleep(time.Duration(d) * time.Millisecond) // aguarda um tempo
}
wg.Wait() // aguarda os subprocessos terminarem
fmt.Println("Dart Vader leaves.") // imprime na tela
}
Muitos Filhos
Quando um processo principal (pai) cria vários filhos, pode ser necessário aguardar que todos eles terminem seu processamento. Para isso, usamos uma forma de sincronização para o pai aguardar os filhos fecharem.
O exemplo abaixo cria n filhos e aguarda eles terminarem. Ele utiliza o sync.WaitGroup para sincronizar os processos.
package main
import (
"fmt"
"math/rand"
"sync"
"time"
)
func child(wg *sync.WaitGroup, id int) { // função do filho
defer wg.Done() // decrementa o sincronizador
for i := 0; i < 5; i++ { // conta até 5
fmt.Println("CHILD[", id, "] ", i) // imprime i
d := rand.Intn(2000) // pega um valor randômico
time.Sleep(time.Duration(d) * time.Millisecond) // pausa um tempo aleatório
}
fmt.Println("CHILD[", id, "] done...") // imprime a finalização
}
func main() { // programa principal
fmt.Println("START PROGRAM...") // imprime na tela
var wg sync.WaitGroup // inicializa o sincronizador
for i := 0; i < 5; i++ { // cria 5 filhos
wg.Add(1) // adiciona um no sincronizador
go child(&wg, i) //cria filho
}
wg.Wait() // aguarda todos os filhos terminarem
fmt.Println("END PROGRAM...") // imprime na tela
}
