Trabalhando em conjunto
Série de artigos:
Concorrência em Go é um tema dos mais interessantes e com aplicações de alto impacto hoje em dia.
E o que é concorrência? E o que é seu irmão, o paralelismo?
Todo processamento paralelo é concorrente, mas nem todo processamento concorrente é paralelo.
No processamento paralelo duas ou mais instruções são executadas ao mesmo tempo em núcleos diferentes.
No processamento concorrente, duas ou mais instruções são enviadas para execução, mas esta execução pode ser feita em um ou mais núcleos.
Quando o escalonador decide executar as instruções em um mesmo núcleo, elas o serão de maneira concorrente, já que concorrerão por uma fatia de tempo de execução neste núcleo. Lembrando que o núcleo de CPU executa uma instrução por vez. (uma simplificação que não leva em conta pipelines em múltiplos estágios etc)
Eventualmente o escalonador deverá migrar instruções para núcleos diferentes disponíveis, e nestes casos, código concorrente irá rodar em paralelo.
A utilização massiva de computadores com diversos núcleos/cpus foi o caminho para continuarmos à escalar o poder de processamento, já que velocidade bruta medida em GHz de clock de CPU estagnou.
Mas com a utilização de concorrência temos uma série de questões a serem resolvidas em nosso código, que se não forem corretamente endereçadas, levam a comportamentos erráticos, respostas incorretas e até mesmo, crashs.
Uma das grandes questões são as race conditions, em português “condições de corrida”.
Este termo vem do fato de que quando introduzimos concorrência e/ou paralelismo em nosso código, introduzimos muitas vezes uma “corrida” para saber quem terá acesso primeiro a determinado dado ou recurso, ou ainda, uma corrida por dados ou recursos em que se perdeu a sincronia que é capas de produzir resultados corretos ao fim do processamento.
Podem ser duas threads, ou no caso de Go, duas goroutines querendo acessar ao mesmo tempo um mesmo dado (data race) ou recurso.
O que acontece se uma goroutine acessa e muda um dado na memória enquanto outra goroutine estava lendo este dado?
E se o dado é apagado por uma goroutine enquanto outra estava lendo ele?
Estes são cenários que podem ser difíceis de debugar e para os quais deve-se prestar muita atenção.
Felizmente Go foi pensada desde o início para escrever código seguro nestas condições e evitar bugs terríveis e que muitas vezes, podem demorar anos para aparecerem.
Falei rapidamente de threads, instruções e goroutines. Agora vamos falar sobre, afinal de contas, O QUE É UMA GOROUTINE?
Uma goroutine é de certa maneira parecida em conceito com uma thread do sistema operacional.
Ela é uma unidade lógica de execução de seu código que roda de maneira independente do restante do software e que faz um trabalho específico.
Uma goroutine, assim que criada, é alocada pelo escalonador do runtime Go de seu software para rodar em algum dos núcleos de CPU disponíveis, incluindo o núcleo em que roda a goroutine principal de seu programa. (sim, em um programa feito em Go, tudo roda dentro de alguma Goroutine, inclusive seu código principal)
Pense em goroutines como uma “thread mais leve” e rápida para ser criada e destruída. Elas consomem pouca memória também.
Com isso, podemos criar goroutines aos milhares, facilmente, mesmo em computadores modestos, sem grandes penalidades de performance.
E isso com os bônus de um gerenciamento descomplicado e grande segurança de uso, com menores chances de bugs comuns em software multithread.
Criamos uma goroutine com a palavra reservada: go.
go func(a Type)No próximo artigo vamos falar um pouco sobre alguns cuidados para evitar race conditions e outras coisas.
Por fim, se você gostou da iniciativa, e puder, com o QR Code abaixo, pode me pagar um café.
Com ele você me envia um PIX com o valor que você escolher.
Ou se preferir, envie usando minha chave PIX: [email protected]
