Go Intermediário : Paralelismo VS Concorrência

Como pretendo fazer uma série de conteúdos focados em Gorotines, é muito importante iniciar por este tema que, acredito, pode causar, às vezes, uma falsa visão de simplicidade. Embora pareçam a mesma coisa, são ideias muito diferentes.

Definições

Concorrência: É um conceito que lida com a execução de várias tarefas aparentemente simultaneamente. Uma aplicação concorrente pode gerenciar várias tarefas em um único núcleo de processador, alternando rapidamente entre elas. O foco é na estrutura da aplicação e em como ela organiza e coordena as tarefas.

Paralelismo: Refere-se à execução de múltiplas tarefas ao mesmo tempo, utilizando múltiplos núcleos de processador. O paralelismo é uma implementação de concorrência e preocupa-se mais com o desempenho e a eficiência da execução, permitindo que várias operações sejam realizadas simultaneamente.

Analogia

Uma boa analogia para entender a diferença é a de um chef de cozinha:

Concorrência: Imagine que o chef é responsável por preparar várias refeições (tarefas). Ele pode começar a preparar um prato enquanto, por exemplo, deixa algo no forno e, enquanto isso, ele também pode começar a cortar legumes para outra receita. Porém, ele não possui assistentes e precisa alternar entre as atividades. O resultado é que ele parece ocupado, mesmo que apenas uma tarefa esteja sendo realmente executada em um dado momento.

Paralelismo: Agora, imagine que o chef tem uma equipe de assistentes. Cada assistente pode cuidar de uma parte diferente do preparo das refeições ao mesmo tempo. Enquanto o chef está cozinhando uma sopa, um assistente está preparando uma salada e outro está assando uma sobremesa. Todas as tarefas estão sendo executadas ao mesmo tempo, resultando em uma refeição pronta mais rápido.

Exemplos

Concorrência: Em uma aplicação web, um servidor pode atender múltiplas requisições de usuários diferentes. Ele pode utilizar técnicas como threads ou "event loops" para alternar rapidamente entre as requisições, fazendo com que os usuários sintam que suas solicitações estão sendo processadas de maneira eficiente, mesmo que, internamente, a aplicação esteja multitarefando em um único núcleo.

Paralelismo: Em um processamento de imagem em um software, você pode dividir uma imagem grande em várias partes e processá-las simultaneamente em múltiplos núcleos do processador. Por exemplo, um núcleo pode ajustar o brilho da metade esquerda da imagem enquanto outro núcleo trabalha na metade direita. Isso reduz o tempo total de processamento.

Prós e Contras

Concorrência

Prós:

  • Efetiva em economizar recursos, pois permite que uma única CPU gerencie várias tarefas.
  • Boa para aplicações que não precisam de processamento intensivo e podem se beneficiar de um tempo de resposta rápido.
  • Útil em situações onde as tarefas são frequentemente bloqueadas, como em operações de I/O.

Contras:

  • Pode introduzir complexidade, como condições de corrida e problemas de sincronização.
  • O overhead das alternâncias entre tarefas pode impactar o desempenho.

Paralelismo

Prós:

  • Melhora significativamente a velocidade em tarefas computacionalmente intensivas, pois consegue utilizar todos os núcleos disponíveis.
  • Reduz o tempo total de execução para aplicações que podem ser divididas em tarefas independentes.

Contras:

  • A divisão de tarefas pode ser complexa e nem todas as tarefas se encaixam bem em um modelo paralelo.
  • Necessita de hardware compatível (múltiplos núcleos) para realmente ver os benefícios.
  • Pode ser mais difícil de implementar corretamente, especialmente no que diz respeito à comunicação e compartilhamento de dados entre as tarefas paralelas.

Conclusão

Ambos os conceitos têm suas próprias aplicações e vantagens. A escolha entre concorrência e paralelismo depende do tipo de tarefa que você está executando. Para aplicações com muitas operações de I/O, a concorrência pode ser mais adequada, enquanto para tarefas computacionais pesadas, o paralelismo é geralmente a melhor escolha. Entender as diferenças e saber como aplicá-las pode melhorar muito a eficiência e a performance de suas aplicações.

Comentários

Postar um comentário

Postagens mais visitadas deste blog

Go Básico: Generics

Imagem
A linguagem Go nasceu sem o recurso conhecido como generics , que é uma forma mais "elegante" de criar novos tipos de parâmetros ( exp: um parâmetro de uma função ) que podem ser compostos de outros tipos. Para ilustrar, podemos criar uma função que some a pontuação de todos os jogadores, representada em um mapa com seus nomes e sua pontuação final, que serão inicialmente números inteiros. package main import "fmt" func main() { scores := map[string]int{"User01": 100, "User02": 150, "User03": 50} fmt.Printf("Final score: %d\n", AddScores(scores)) } func AddScores(scores map[string]int) int { var total int for _, score := range scores { total += score } return total } Agora, vamos imaginar que precisamos lidar não apenas com o nosso mapa que representa os pontos em números inteiros, mas também com um novo mapa que representa a pontuação com números decimais. Essa simples alteração faria com que noss...
Leia mais

Go Básico: Manipulação de Arquivos

Imagem
Todo desenvolvedor em algum momento já se deparou com a necessidade de manipular e escrever arquivos, não é mesmo? Em Go, existem algumas maneiras bem simples de resolvermos essa necessidade de forma rápida. Para criar um novo arquivo e escrever algum conteúdo neste novo arquivo, podemos escrever o seguinte código. package main import ( "fmt" "os" ) func main() { //Creating a new file f, err := os.Create("test.txt") if err != nil { panic(err) } defer f.Close() //Writing to the new file. size, err := f.Write([]byte("Hello World!")) if err != nil { panic(err) } fmt.Printf("Size file: %d bytes", size) //If the content of your file is only text, you can opt for this other function. //size, err := f.WriteString("Hello World") } Agora que já criamos e escrevemos em um novo arquivo, podemos realizar a leitura deste arquivo com o seguinte código: package main import ( "fmt" ...
Leia mais

Go Básico: Testando Saída do Console (stdout) com os.Pipe

Imagem
Testar a saída do console em programas Go pode ser um desafio, especialmente quando queremos garantir que nossas funções estão imprimindo o resultado correto em nossas aplicações de CLI. Neste artigo, vamos explorar como usar os.Pipe para capturar e verificar a saída do console de maneira eficaz, permitindo a criação de testes unitários robustos para suas funções que escrevem na saída padrão ( os.Stdout ). Para exemplificar, vamos utilizar o seguinte exemplo como demonstração, simulando uma possível aplicação. package main import ( "fmt" ) func printSomething(s string) { fmt.Println(s) } func main() { printSomething("Hello, World!") } Agora vamos supor que queremos testar esta função printSomething e validar se ela realmente está imprimindo o que desejamos de maneira correta. package main import ( "io" "os" "testing" ) func Test_printSomething(t *testing.T) { // Save the original standard output stdOut :=...
Leia mais