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:
1package main
2
3import (
4 "fmt"
5)
6
7func hello() {
8 fmt.Println("Hello world goroutine")
9}
10func main() {
11 go hello()
12 // Vamos dar uma pausa aqui senão o programa pode terminar
13 // antes de executar a gorotine
14 time.Sleep(1 * time.Second)
15 fmt.Println("main function")
16}
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.
1package main
2
3import (
4 "fmt"
5 "math/rand"
6 "sync"
7 "time"
8)
9
10func child(wg *sync.WaitGroup) {
11 defer wg.Done() // decrementa o contador de processo
12 fmt.Println("Luke: Noooooo.....") // imprime na tela
13 for i := 0; i < 5; i++ { // executa o laço 5 vezes
14 fmt.Println("Luke: No!") // imprime n a tela
15 d := rand.Intn(2000) // retorna um número randômico de 0 a 1999
16 time.Sleep(time.Duration(d) * time.Millisecond) // aguarda um tempo
17 }
18 fmt.Println("Luke Skywalker falls.") // imprime na tela
19}
20
21func main() {
22 var wg sync.WaitGroup // wg é tilizado para sincronizar os processos
23 wg.Add(1) // incrementa o contador de processos
24 go child(&wg) // chama a rotina child paralelamente
25 fmt.Println("Vader: Luke! I am your father...") // imprime na tela
26 for i := 0; i < 5; i++ { // executa o laço 5 vezes
27 fmt.Println("Vader: Yes!") // imprime na tela
28 d := rand.Intn(2000) // retorna um número randômico de 0 a 1999
29 time.Sleep(time.Duration(d) * time.Millisecond) // aguarda um tempo
30 }
31 wg.Wait() // aguarda os subprocessos terminarem
32 fmt.Println("Dart Vader leaves.") // imprime na tela
33}
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.
1package main
2
3import (
4 "fmt"
5 "math/rand"
6 "sync"
7 "time"
8)
9
10func child(wg *sync.WaitGroup, id int) { // função do filho
11 defer wg.Done() // decrementa o sincronizador
12 for i := 0; i < 5; i++ { // conta até 5
13 fmt.Println("CHILD[", id, "] ", i) // imprime i
14 d := rand.Intn(2000) // pega um valor randômico
15 time.Sleep(time.Duration(d) * time.Millisecond) // pausa um tempo aleatório
16 }
17 fmt.Println("CHILD[", id, "] done...") // imprime a finalização
18}
19
20func main() { // programa principal
21 fmt.Println("START PROGRAM...") // imprime na tela
22 var wg sync.WaitGroup // inicializa o sincronizador
23 for i := 0; i < 5; i++ { // cria 5 filhos
24 wg.Add(1) // adiciona um no sincronizador
25 go child(&wg, i) //cria filho
26 }
27 wg.Wait() // aguarda todos os filhos terminarem
28 fmt.Println("END PROGRAM...") // imprime na tela
29}
