Welke hoofdconstructies worden gebruikt voor het beheren en uitvoeren van goroutines in de programmeertaal?

Om goroutines in Go te beheren en uit te voeren, worden de volgende hoofdconstructies gebruikt:

• Starten van een goroutine: het sleutelwoord go vóór het aanroepen van een functie start deze in een aparte goroutine, bijvoorbeeld:

  go mijnFunctie()
  

  Dit maakt het mogelijk om de functie asynchroon uit te voeren.

• Kanalen (channels): worden gebruikt voor synchronisatie en gegevensuitwisseling tussen goroutines. Een kanaal wordt zo gemaakt:

  ch := make(chan int)
  

  Gegevens verzenden en ontvangen:

  ch <- 42      // verzenden
  val := <-ch   // ontvangen
  

  Kanalen zorgen voor veilige communicatie en blokkeren de goroutine als de gegevens nog niet klaar zijn.

• sync.WaitGroup: wordt gebruikt om te wachten tot een groep goroutines klaar is. Voorbeeld:

  var wg sync.WaitGroup
  wg.Add(1)
  go func() {
      defer wg.Done()
      // werk van de goroutine
  }()
  wg.Wait() // wachten tot alle goroutines klaar zijn
  

• select: maakt het mogelijk om meerdere operaties op kanalen gelijktijdig te wachten en de operation die klaar is te kiezen. Voorbeeld:

  select {
  case msg := <-ch1:
      fmt.Println("Ontvangen van ch1:", msg)
  case ch2 <- 42:
      fmt.Println("Verzonden naar ch2")
  default:
      fmt.Println("Geen operatie klaar")
  }
  

Deze constructies maken het mogelijk om efficiënt parallel uitvoeren te starten, te synchroniseren en te beheren in Go.