Contadores atómicos en Go concurrente

Introducción

Esta práctica se centra en la gestión del estado en Go utilizando el paquete sync/atomic para contadores atómicos accedidos por múltiples goroutines.

Contadores atómicos

El problema consiste en incrementar un contador exactamente 1000 veces utilizando 50 goroutines y el paquete sync/atomic.

• Utilice el paquete sync/atomic para incrementar el contador.
• Utilice un WaitGroup para esperar a que todas las goroutines terminen su trabajo.

## Esperamos obtener exactamente 50.000 operaciones. Si hubiéramos
## utilizado el no atómico `ops++` para incrementar el contador,
## probablemente obtendríamos un número diferente, que variaría
## entre ejecuciones, porque las goroutines se interpondrían
## entre sí. Además, obtendríamos errores de carrera de datos
## al ejecutar con la bandera `-race`.
$ go run atomic-counters.go
ops: 50000

## A continuación veremos los mutexes, otra herramienta para
## la gestión del estado.

A continuación se muestra el código completo:

// El principal mecanismo para la gestión del estado en Go es
// la comunicación a través de canales. Vimos esto por ejemplo
// con [piscinas de trabajadores](worker-pools). Sin embargo,
// hay otras opciones para la gestión del estado. Aquí
// veremos cómo utilizar el paquete `sync/atomic` para
// _contadores atómicos_ accedidos por múltiples goroutines.

package main

import (
	"fmt"
	"sync"
	"sync/atomic"
)

func main() {

	// Utilizaremos un entero sin signo para representar nuestro
	// contador (que siempre es positivo).
	var ops uint64

	// Un WaitGroup nos ayudará a esperar a que todas las goroutines
	// terminen su trabajo.
	var wg sync.WaitGroup

	// Iniciaremos 50 goroutines que cada una incrementará el
	// contador exactamente 1000 veces.
	for i := 0; i < 50; i++ {
		wg.Add(1)

		go func() {
			for c := 0; c < 1000; c++ {
				// Para incrementar el contador de forma atómica
				// utilizamos `AddUint64`, pasándole la dirección
				// de memoria de nuestro contador `ops` con la
				// sintaxis `&`.
				atomic.AddUint64(&ops, 1)
			}
			wg.Done()
		}()
	}

	// Espera hasta que todas las goroutines hayan terminado.
	wg.Wait()

	// Ahora es seguro acceder a `ops` porque sabemos
	// que ninguna otra goroutine está escribiendo en él.
	// También es posible leer atómicos de forma segura
	// mientras se están actualizando, utilizando funciones
	// como `atomic.LoadUint64`.
	fmt.Println("ops:", ops)
}

Resumen

En esta práctica, aprendimos cómo utilizar el paquete sync/atomic para gestionar el estado en Go al incrementar un contador utilizando múltiples goroutines. La función AddUint64 se utilizó para incrementar el contador de forma atómica, y un WaitGroup se utilizó para esperar a que todas las goroutines terminaran su trabajo.