# Concorrência

Diz-se que Go é a linguagem C do século XXI. Eu acho que existem duas razões: primeiro, o Go é uma linguagem simples; segundo, a simultaneidade é um tema importante no mundo atual, e o Go suporta esse recurso no nível da linguagem.

## goroutine
 
goroutines e simultaneidade são incorporados ao design central do Go. Eles são semelhantes aos tópicos, mas funcionam de maneira diferente. Mais de uma dúzia de goroutines talvez tenham apenas 5 ou 6 threads subjacentes. Go também lhe dá suporte total para compartilhar memória em seus goroutines. Uma goroutine geralmente usa 4 ~ 5 KB de memória de pilha. Portanto, não é difícil executar milhares de goroutines em um único computador. Uma goroutine é mais leve, mais eficiente e mais conveniente que os threads do sistema.

Os goroutines são executados no gerenciador de encadeamentos em tempo de execução no Go. Usamos a palavra-chave `go` para criar uma nova goroutine, que é uma função no nível subjacente (*** main () é uma goroutine ***).

	go hello(a, b, c)
	
Vamos ao exemplo:

	package main

	import (
    	"fmt"
    	"runtime"
	)

	func say(s string) {
    	for i := 0; i < 5; i++ {
        	runtime.Gosched()
        	fmt.Println(s)
    	}
	}

	func main() {
    	go say("world") // create a new goroutine
    	say("hello") // current goroutine
	}

Retorno

	hello
	world
	hello
	world
	hello
	world
	hello
	world
	hello
	
Vemos que é muito fácil usar a simultaneidade no Go usando a palavra-chave `go`. No exemplo acima, essas duas goroutines compartilham alguma memória, mas seria melhor seguir a receita de design: Não use dados compartilhados para se comunicar, use a comunicação para compartilhar dados.

runtime.Gosched () significa deixar a CPU executar outras goroutines e voltar em algum momento.

O agendador usa apenas um thread para executar todos os goroutines, o que significa que ele apenas implementa a simultaneidade. Se você deseja usar mais núcleos de CPU para aproveitar o processamento paralelo, é necessário chamar runtime.GOMAXPROCS (n) para definir o número de núcleos que deseja usar. Se `n <1`, nada muda. Esta função pode ser removida no futuro, veja mais detalhes sobre o processamento paralelo e simultaneidade neste [artigo(em inglês)](http://concur.rspace.googlecode.com/hg/talk/concur.html#landing-slide).

## Canais(Channels)

Os goroutines são executados no mesmo espaço de endereço de memória, portanto, você precisa manter a sincronização quando quiser acessar a memória compartilhada. Como você se comunica entre diferentes goroutines? Go usa um mecanismo de comunicação muito bom chamado `channel`. `channel` é como um pipeline bidirecional em shells Unix: use` channel` para enviar ou receber dados. O único tipo de dado que pode ser usado em canais é o tipo `channel` e a palavra-chave` chan`. Esteja ciente de que você tem que usar `make` para criar um novo` channel`.

	ci := make(chan int)
	cs := make(chan string)
	cf := make(chan interface{})
	
canais usa, o operador `<-` para enviar ou receber dados.

	ch <- v    // envia v para o canal ch.
	v := <-ch  // recebe dados de ch, e os assina em v
	
Exemplos:

	package main

	import "fmt"

	func sum(a []int, c chan int) {
    	total := 0
    	for _, v := range a {
        total += v
    	}
    	c <- total  // envia o total para c
	}

	func main() {
    	a := []int{7, 2, 8, -9, 4, 0}

    	c := make(chan int)
    	go sum(a[:len(a)/2], c)
    	go sum(a[len(a)/2:], c)
    	x, y := <-c, <-c  // recebe de c

    	fmt.Println(x, y, x + y)
	}
	
Enviando e recebendo dados em blocos de canais por padrão, é muito mais fácil usar goroutines síncronas. O que quero dizer com block é que uma goroutine não continuará ao receber dados de um canal vazio, ou seja, (`value: = <-ch`), até que outras goroutines enviem dados para este canal. Por outro lado, a goroutine não continuará até que os dados enviados a um canal, ou seja (`ch <-5`), sejam recebidos.

## Canais em Buffer

Eu introduzi canais não-bufferizados acima. Go também tem canais em buffer que podem armazenar mais de um único elemento. Por exemplo, `ch: = make (chan bool, 4)`, aqui criamos um canal que pode armazenar 4 elementos booleanos. Assim, neste canal, podemos enviar 4 elementos sem bloqueio, mas a goroutine será bloqueada quando você tentar enviar um quinto elemento e nenhuma goroutine o receber.

	ch := make(chan type, n)

	n == 0 ! non-buffer（block）
	n > 0 ! buffer（non-block until n elements in the channel）
	
Você pode tentar o seguinte código no seu computador e alterar alguns valores.
	
	package main

	import "fmt"

	func main() {
    	c := make(chan int, 2)  // altera de 2 para 1 e retornará um erro, mas 3 funciona
    	c <- 1
    	c <- 2
    	fmt.Println(<-c)
    	fmt.Println(<-c)
	}
	
## Alcance e fechamento(Range and Close)

Podemos usar o range para operar em canais buffer como em slice e map.

	package main

	import (
    	"fmt"
	)

	func fibonacci(n int, c chan int) {
    	x, y := 1, 1
    	for i := 0; i < n; i++ {
        	c <- x
        	x, y = y, x + y
    	}
    	close(c)
	}

	func main() {
    	c := make(chan int, 10)
    	go fibonacci(cap(c), c)
    	for i := range c {
    	    fmt.Println(i)
    	}
	}
	
`for i := range c` não parará de ler dados do canal até que o canal seja fechado. Usamos a palavra-chave `close` para fechar o canal no exemplo acima. É impossível enviar ou receber dados em um canal fechado; você pode usar `v, ok: = <-ch` para testar se um canal está fechado. Se `ok` retornar falso, significa que não há dados nesse canal e foi fechado.

Lembre-se sempre de fechar os canais nos produtores e não nos consumidores, ou é muito fácil entrar em status de pânico.

Outra coisa que você precisa lembrar é que os canais não são como arquivos. Você não precisa fechá-los com frequência, a menos que tenha certeza de que o canal é completamente inútil ou deseja sair de loops de intervalo.

## Select

Nos exemplos acima, usamos apenas um canal, mas como podemos lidar com mais de um canal? Go tem uma palavra-chave chamada `select` para ouvir muitos canais.

`select` está bloqueando por padrão e continua a executar somente quando um dos canais tem dados para enviar ou receber. Se vários canais estiverem prontos para usar ao mesmo tempo, selecione a opção para executar aleatoriamente.

	package main

	import "fmt"

	func fibonacci(c, quit chan int) {
    	x, y := 1, 1
    	for {
        	select {
        	case c <- x:
            	x, y = y, x + y
        	case <-quit:
        	fmt.Println("quit")
            	return
        	}
    	}
	}

	func main() {
    	c := make(chan int)
    	quit := make(chan int)
    	go func() {
        	for i := 0; i < 10; i++ {
            	fmt.Println(<-c)
        	}
        	quit <- 0
    	}()
    	fibonacci(c, quit)
	}
	
`select` tem um caso` default`, assim como `switch`. Quando todos os canais não estão prontos para uso, ele executa o caso padrão (ele não aguarda mais o canal).

	select {
	case i := <-c:
    	// use i
	default:
    	// Executa aqui quando C estiver bloqueado
	}
	
## Timeout

Às vezes uma goroutine fica bloqueada. Como podemos evitar isso para evitar que todo o programa bloqueie? É simples, podemos definir um tempo limite no select.

	func main() {
    	c := make(chan int)
    	o := make(chan bool)
    	go func() {
        	for {
            	select {
                	case v := <- c:
                   		println(v)
                	case <- time.After(5 * time.Second):
                    	println("timeout")
                    	o <- true
                    	break
            	}
        	}
    	}()
    	<- o
	}
	
## Runtime goroutine

O pacote `runtime` tem algumas funções para lidar com goroutines.

- `runtime.Goexit ()`

Sai da gorout atual, mas as funções adiadas serão executadas como de costume.

- `runtime.Gosched ()`

Permite que o planejador execute outras goroutines e volte em algum momento.

- `runtime.NumCPU () int`

Retorna o número de núcleos da CPU

- `runtime.NumGoroutine () int`

Retorna o número de goroutines

- `runtime.GOMAXPROCS (n int) int`

Define quantos núcleos de CPU você deseja usar

## Links

- [Prefácio](preface.md)
- Seção anterior: [interfaces](02.6.md)
- Próxima seção: [Summary](02.8.md)