Goroutines

Les goroutines sont des fonctions qui s’exécutent en concurrence avec d’autres et dans le même espace d’adresse. Elles permettent, par exemple, de lancer plusieurs requêtes HTTP en concurrence et de ne pas avoir à attendre qu’une requête HTTP se termine pour en lancer une autre.

Channels

Les channels sont des moyens de communication et de synchronisation entre les goroutines. Autrement dit, elles permettent de « transmettre » des données (int, string, struct…) entre des fonctions concurrentes (goroutines).

sync.WaitGroup

WaitGroup est une primitive de synchronisation de goroutines proposé dans le package sync de la libraire Golang. Elle propose trois méthodes Add, Done et Wait qui permettent de, respectivement: incrémenter le nombre de goroutine à attendre, décrémenter le nombre de goroutines à attendre et bloquer l’exécution du code jusqu’à ce que le nombre de goroutines à attendre arrive à 0.

Le code source présenté dans cet épisode :

package main

import (
  "fmt"
  "io/ioutil"
  "net/http"
  "time"
)

var wg sync.WaitGroup

func fetch(url string) {
  defer wg.Done()

  start_time := time.Now()
  resp, err := http.Get(url)
  end_time := time.Since(start_time)

  if err != nil {
    fmt.Println(err)
    return
  }

  body, err := ioutil.ReadAll(resp.Body)
  if err != nil {
    fmt.Println(err)
    return
  }

  defer resp.Body.Close()

  fmt.Printf("Site : %s | Length :%d | Processing time : %s \n", url, len(body), end_time)
}

func main() {
  fmt.Println("Hello gophers")
  urls := []string{"https://wikipedia.org", "https://goolge.com",
  "https://facebook.com", "http://exemple.com"}
  size := len(urls)
  wg.Add(size)

  for _, url := range urls {
    go fetch(url)
  }

  wg.Wait()
}