GO: Paralelismo e concorrência

Paralelismo e concorrência em GO foi na verdade o primeiro assunto que me fez ter interesse em aprender essa linguagem, apesar do meu objetivo inicial ter sido ver como ela tratava o paralelismo só hoje que eu fui de fato estudar sobre.

Diferenças entre concorrência e paralelismo

Na concorrência os processos são disparados ao mesmo tempo mas como é usado apenas um core, um processo vai parar para que o outro possa rodar e ai eles vão sendo intercalados.

No paralelismo os dois processos são iniciados ao mesmo tempo, mas cada um é processado em um core diferente do processador, fazendo assim com que os dois possam ser processados simultaneamente

Go routines

  func main() {
    runProcess("Process 1", 20)
    runProcess("Process 2", 20)

}

func runProcess(name string, total int) {
    for i := 0; i < total; i++ {
        fmt.Println(name, i)
        t := time.Duration(rand.Intn(255))
        time.Sleep(time.Millisecond * t)
    }
}

Essa função definida acima dessa forma inicial vai primeiro printar 20 vezes no terminal "Process 1" esperando sempre um tempo aleatório em milissegundos para o segundo print, e depois vai printar mais 20 vezes "Process 2".

Adicionando um operador go na frente de cada uma da chamada das funções vai fazer com que ela rodem em paralelo e em background. Agora ao invés de esperarmos a primeira função rodar para só então a segunda ser executada, com o go na frente enquanto uma função está esperando o timeout passar a outra é executada (se não definíssemos um timeout como é uma função muito simples na hora que o programa chegasse na segunda função a primeira já teria terminado de executar e não daria para ver o efeito da go routine)

porém se somente adicionar o go na frente da função o terminal não vai exibir nada, por que as funções estão rodando em background então na verdade o go vai achar que elas já terminaram de rodar e terminar a execução. Para resolver esse problema precisamos criar um waitGroup e para fazer com que o Go espere a função terminar de rodar para ai sim matar a aplicação.

var waitGroup sync.WaitGroup

func main() {
    waitGroup.Add(2)

    go runProcess("Process 1", 20)
    go runProcess("Process 2", 20)

    waitGroup.Wait()

}

func runProcess(name string, total int) {
    for i := 0; i < total; i++ {
        fmt.Println(name, i)
        t := time.Duration(rand.Intn(255))
        time.Sleep(time.Millisecond * t)
    }
    waitGroup.Done()
}

No main adicionei duas funções ao waitGroup e na função runProcess falo que o waitGroup concluiu o trabalho depois do for.

Mas agora fica a questão, o Go está usando paralelismo ou concorrência? e na verdade depende, nesse caso é paralelismo pois tenho uma CPU de 6 cores então por default ele associa cada função a um core, porem se eu tivesse apenas 1 core no processador ele rodaria as duas funções de forma concorrente

podemos testar também rodar de forma concorrente adicionando uma função init e setando o numero máximo de cores que permitimos o GO usar. porem se fizermos isso para esse caso o output será o mesmo

func init() {
    runtime.GOMAXPROCS(1)
}

Race conditions

Race conditions é um tipo de problemas que temos com o pararelismo onde a execução dos codigos em pararelo compromete de alguma forma as regras de negocio da aplicação, então por exemplo caso eu queira executar o total de vezes que o for rodou

var result int
var waitGroup sync.WaitGroup

func main() {

    waitGroup.Add(2)

    go runProcess("Process 1", 20)
    go runProcess("Process 2", 20)

    waitGroup.Wait()
    fmt.Println("Result:", result)
}

func runProcess(name string, total int) {
    for i := 0; i < total; i++ {
        z := result
        z++
        t := time.Duration(rand.Intn(255))
        time.Sleep(time.Millisecond * t)
        result = z
        fmt.Println(name, "->", i, result)
    }
    waitGroup.Done()
}

no meu println com mostrando o result que deveria ser 40 na verdade o output vai ser 20 e podemos ver que o valor de result de fato está sendo reatribuindo para um valor anterior constantemente por causa da execução anterior ainda não ter o novo valor que result deveria ter

se rodarmos o programa com go run -race main.go o proprio go já detecta se está ocorrendo uma race condition e se sim em quais linhas

para resolver o problema de race condition é bem simples basta usarmos o Mutex onde travamos uma operação até ela terminar de rodar para impedir que ela seja sobescrita no meio

func runProcess(name string, total int) {
    for i := 0; i < total; i++ {

        t := time.Duration(rand.Intn(255))
        time.Sleep(time.Millisecond * t)
        m.Lock()
        result++
        fmt.Println(name, "->", i, "total", result)
                m.Unlock()
    }
    waitGroup.Done()
}

Agora os processos ficam travados esperando o result terminar de aumentar o seu valor, e só quando dou o unlock eles continuam. Se rodarmos a aplicação detectando race conditions podemos ver que agora nada foi detectado