M25 Gijon Predictions

Rising Star vs. Veteran Challenger

Rising Star

<|repo_name|>thiagocamposm/golang-go-routine<|file_sep|>/exercicios/exercicio-02/main.go package main import ( "fmt" "time" ) func main() { var done = make(chan int) go func() { time.Sleep(3 * time.Second) done <- 1 }() select { case <-done: fmt.Println("Foi executado o goroutine") default: fmt.Println("Não foi executado o goroutine") } fmt.Println("Executando main") } <|file_sep|># Concorrença e Paralelismo ## Introdução O que é concorrência? Concorrência é o estado de um programa que está executando múltiplas tarefas ao mesmo tempo. O que é paralelismo? Paralelismo é o estado de um programa que está executando múltiplas tarefas ao mesmo tempo em diferentes núcleos de CPU. Os conceitos de concorrência e paralelismo não são exclusivos da linguagem Go. Agora vamos falar sobre o que torna Go especial. ## Goroutines Em Go podemos criar Goroutines simplesmente usando `go`. Vamos ver como podemos criar uma Goroutine: go func sayHello() { fmt.Println("Hello!") } func main() { go sayHello() fmt.Println("Main!") } Uma Goroutine é simplesmente uma função que é executada em uma thread independente gerenciada pela implementação da linguagem Go. O que acontece quando executamos o código acima? Na maioria das linguagens de programação quando você executa um programa você terá uma thread principal e quando você cria uma nova thread ela se torna uma thread secundária e deve ser explicitamente iniciada. Em Go quando você usa `go` para chamar uma função essa função se torna uma Goroutine e é iniciada automaticamente pela implementação da linguagem Go. Vamos executar nosso programa: bash $ go run main.go Main! Observe que o `sayHello()` não foi chamado! Isso ocorre porque o tempo de execução da linguagem Go não espera que todas as Goroutines sejam concluídas antes de encerrar o programa. Uma Goroutine precisa ser explicitamente iniciada na maioria das linguagens de programação e isso geralmente requer código adicional. No entanto em Go isso é feito por padrão pelo compilador e executor da linguagem sem código adicional do desenvolvedor. Como podemos fazer com que nosso programa espere até que todas as Goroutines sejam concluídas? Vamos usar um canal para fazer isso: go func sayHello(done chan bool) { fmt.Println("Hello!") done <- true } func main() { done := make(chan bool) go sayHello(done) <-done fmt.Println("Main!") } Observe que agora passamos um canal como parâmetro para nossa função `sayHello()` e depois dela enviamos um valor booleano para ele. No `main()` criamos um canal usando `make()` e depois esperamos por um valor nesse canal usando `<-`. Isso faz com que nosso programa espere até que algo seja enviado para esse canal! Vamos executar nosso programa novamente: bash $ go run main.go Hello! Main! Parabéns! Agora temos um programa concorrente! Observe que agora podemos passar dados entre Goroutines usando canais! Também podemos usar os recursos do sistema operacional como threads usando Goroutines sem escrever código adicional! Isso torna muito mais fácil escrever programas concorrentes em Go! Você pode ver mais sobre os recursos do sistema operacional usando Goroutines [neste artigo](https://medium.com/a-journey-with-go/go-goroutines-synchronization-91b41c59f9b0). ## Concorrentemente ou Paralelamente? Para entender melhor essa diferença vamos analisar alguns códigos: ### Código Concorrente go func sayHello() { fmt.Println("Hello!") } func main() { go sayHello() go sayHello() fmt.Println("Main!") } Esse código não é paralelo porque ele só usa uma única thread para executar suas duas tarefas `sayHello()` simultaneamente! Se você tiver apenas uma CPU então seu computador só pode executar uma única tarefa ao mesmo tempo! Se você tiver duas CPUs então seu computador pode executar duas tarefas ao mesmo tempo! No entanto o código acima será concorrente independentemente do número de CPUs porque ele está tentando executar duas tarefas simultaneamente! ### Código Paralelo Agora vamos modificar nosso código anterior para torná-lo paralelo: go func sayHello() { fmt.Println("Hello!") } func main() { if runtime.NumCPU() > 1 { runtime.GOMAXPROCS(1) } go sayHello() go sayHello() fmt.Println("Main!") } Primeiro usamos `runtime.NumCPU()` para verificar quantas CPUs temos disponíveis no sistema operacional atual e depois usamos `runtime.GOMAXPROCS(1)` para limitar o número de CPUs usadas pelo nosso programa. Isso faz com que nosso programa execute apenas uma tarefa por vez! Agora vamos tentar rodar esse código em um computador com duas CPUs: bash $ go run main.go Main! Hello! Hello! Observe que agora temos dois resultados diferentes! Isso ocorre porque temos duas CPUs disponíveis no sistema operacional atual e estamos limitando o uso delas para apenas uma CPU! Isso faz com que nossas duas tarefas `sayHello()` sejam executadas paralelamente em diferentes núcleos de CPU! Parabéns! Agora você sabe como escrever programas concorrentes e paralelos em Go! ## Conclusão Neste artigo aprendemos sobre os conceitos de concorrência e paralelismo em Go e como podemos criar programas concorrentes usando Goroutines e canais. Também vimos como podemos usar os recursos do sistema operacional como threads usando Goroutines sem escrever código adicional! Espero que este artigo tenha ajudado você a entender melhor esses conceitos importantes na linguagem Go! Se você quiser aprender mais sobre concorrência em Go recomendo [este livro](https://www.amazon.com/gp/product/1491941296/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1491941296&linkCode=as2&tag=jakebathman-20&linkId=8d014f26c87c71f14fdaf7cfc6d7d35c). Boa sorte com seus projetos em Go! <|repo_name|>thiagocamposm/golang-go-routine<|file_sep|>/exercicios/exercicio-01/main.go package main import ( "fmt" "time" ) func count(num int) { for i := 0; i <= num; i++ { time.Sleep(time.Second) fmt.Printf("%dn", i) } } func main() { go count(5) go count(10) time.Sleep(11 * time.Second) } <|repo_name|>thiagocamposm/golang-go-routine<|file_sep|>/README.md # GO - GO ROUTINE ![Go Logo](https://upload.wikimedia.org/wikipedia/commons/thumb/1/1b/Go_Logo_Blue.svg/1200px-Go_Logo_Blue.svg.png) ## 🎓 Aula 01 - Introdução à GO ROUTINE * [Vídeo](https://youtu.be/hZwMHRf7S1U) * [Slides](https://docs.google.com/presentation/d/1w6kFy1qCQHsLXv3tIgKMQ6bKzgZPv7Ez/edit?usp=sharing&ouid=115763483613549924664&rtpof=true&sd=true) ## 🎓 Aula 02 - GO ROUTINE vs THREADS * [Vídeo](https://youtu.be/4RzQIeptQYk) * [Slides](https://docs.google.com/presentation/d/1G0XU36JiGOGIirNJP-FILRtL1UpTtDZq/edit?usp=sharing&ouid=115763483613549924664&rtpof=true&sd=true) ## 🎓 Aula 03 - Concorrência vs Paralelismo * [Vídeo](https://youtu.be/Ehg1F-cJLmc) * [Slides](https://docs.google.com/presentation/d/19r63QjLmp6KZGAM9jgY4nQqYw3uNpqJx/edit?usp=sharing&ouid=115763483613549924664&rtpof=true&sd=true) ## 🎓 Aula 04 - Escalabilidade com GO ROUTINE * [Vídeo](https://youtu.be/ZgNvBnA_sGs) * [Slides](https://docs.google.com/presentation/d/1DjYv8-DuL94sIPTu4Oog_0

M25 Gijon stats & predictions

Explore the Thrills of Tennis M25 Gijon Spain

Why Choose Our Expert Betting Predictions?

The Excitement of M25 Tennis in Gijon

How to Navigate Our Platform

The Art of Tennis Betting: Strategies and Tips

Daily Match Highlights: What's On Today?

Tips for Newcomers: Getting Started with Tennis Betting

Detailed Expert Predictions for Today's Matches

Rising Star vs. Veteran Challenger

Rising Star