En el paquete de sincronización del lenguaje Go, se proporcionan unidades de sincronización básicas, como bloqueos mutex. A excepción de los tipos Once y WaitGroup, la mayoría de ellos son adecuados para subprocesos de programa de bajo nivel, y es mejor utilizar la comunicación de canal para la sincronización de alto nivel.
Podemos usar el método wait () en WaitGroup para bloquear el hilo principal hasta que los otros hilos secundarios o corrutinas hayan terminado de ejecutarse, y luego volver al hilo principal.
Grupo de espera de sincronización WaitGroup
escriba WaitGroup struct { noCopy noCopy state1 [12] byte sema uint32 }
WaitGroup se usa para esperar el final de un grupo de subprocesos o corrutinas . Thread llama al método Add para establecer la cantidad de subprocesos que deben esperar. Cada hilo en espera debe llamar al método Done al final. Al mismo tiempo, el hilo principal puede llamar al método Wait para bloquearse, esperar a que el hilo declarado en el método Add () se ejecute hasta el final y luego volver al hilo principal.
Métodos en WaitGroup
- func (wg * WaitGroup) Add (delta int) El
método Add agrega delta al recuento interno, delta puede ser un número negativo; si el contador interno se vuelve 0, se liberarán todos los subprocesos bloqueados por el método Wait; si el contador es menor que 0, Método de pánico. Tenga en cuenta que la llamada con Agregar más un número positivo debe usarse antes de Wait; de lo contrario, Wait solo puede esperar unos pocos hilos. En general, se debe llamar al método Add () antes de crear un nuevo hilo u otro evento que se debe esperar. - func (wg * WaitGroup) Done () El
método Done reduce el valor del contador WaitGroup y debe ejecutarse al final del hilo. - func (wg * WaitGroup) Wait () El
método Wait se bloquea hasta que el contador WaitGroup se reduce a 0.
Caso 1. WaitGroup bloquea la función principal a través de wait () para ejecutar 3 subcorutinas.
//myWaitGroupDes.go
// myWatiGroupDes project main.go
package main
import (
"fmt"
"math/rand"
"sync"
"time"
)
func printNumA(wg *sync.WaitGroup) {
k := 0
for i := 11; i <= 20; i += 2 {
fmt.Printf("子协程A[%d]= %d \n", k, i)
time.Sleep(time.Duration(rand.Intn(1000)))
k++
}
wg.Done() //计算器减1
}
func printNumB(wg *sync.WaitGroup) {
k := 0
for i := 22; i <= 30; i += 2 {
fmt.Printf("子协程B[%d]= %d \n", k, i)
time.Sleep(time.Duration(rand.Intn(1000)))
k++
}
wg.Done() //计算器减1
}
func printNumC(wg *sync.WaitGroup) {
k := 0
for i := 'a'; i <= 'e'; i++ {
fmt.Printf("子协程C[%d]= %c \n", k, i)
time.Sleep(time.Duration(rand.Intn(1000)))
k++
}
wg.Done() //计算器减1
}
func main() {
var wg sync.WaitGroup
fmt.Printf("%T\n", wg)
fmt.Println(wg)
wg.Add(3)
rand.Seed(time.Now().UnixNano())
go printNumA(&wg)
go printNumB(&wg)
go printNumC(&wg)
wg.Wait()
fmt.Println("main解除阻塞,main is over...")
}
El efecto es el siguiente:
