Concurrencia: goroutines y canales

func main() {
	var wg sync.WaitGroup // como un CountDownLatch que cuenta solo

	for _, url := range []string{"a.com", "b.com", "c.com"} {
		wg.Add(1)
		go func() {              // "go" lanza la función en una goroutine. Ya está.
			defer wg.Done()
			descargar(url)       // las 3 descargas corren EN PARALELO
		}()
	}

	wg.Wait() // bloquea hasta que todas llamen Done()
	fmt.Println("todas listas")
}

func main() {
	// Canal sin buffer: enviar BLOQUEA hasta que alguien reciba (cita a ciegas)
	resultados := make(chan string)

	go func() { resultados <- consultarAPI("clima") }()
	go func() { resultados <- consultarAPI("noticias") }()

	// Recibir también bloquea hasta que llegue algo:
	fmt.Println(<-resultados) // el primero que termine
	fmt.Println(<-resultados) // el segundo

	// Canal CON buffer: enviar no bloquea hasta llenarlo (cola de tamaño N)
	cola := make(chan int, 5)
	cola <- 1
	cola <- 2
	close(cola)              // el emisor cierra cuando no enviará más

	for v := range cola {    // range consume hasta que el canal se cierre
		fmt.Println(v)
	}
}

// select es un switch para operaciones de canal: ejecuta el caso que
// esté listo primero. Es la base de timeouts, cancelación y multiplexado.
select {
case datos := <-canalDatos:
	procesar(datos)
case err := <-canalErrores:
	log.Println("falló:", err)
case <-time.After(2 * time.Second):
	fmt.Println("timeout: nadie respondió en 2s")
case <-ctx.Done():
	fmt.Println("cancelado desde arriba:", ctx.Err())
}

// Si la operación completa no termina en 3s, TODO lo que cuelgue de ctx
// (queries SQL, llamadas HTTP, goroutines) recibe la señal de cancelación.
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel() // SIEMPRE, aunque termine antes: libera el timer

fila := db.QueryRowContext(ctx, "SELECT nombre FROM usuarios WHERE id=$1", id)
req, _ := http.NewRequestWithContext(ctx, "GET", url, nil)

// En un handler HTTP, el contexto ya viene creado y se cancela solo
// si el cliente corta la conexión:
func handler(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	// pásalo hacia abajo y toda la cadena se vuelve cancelable
}

func main() {
	trabajos := make(chan int, 100)
	resultados := make(chan string, 100)

	// 4 workers compitiendo por el mismo canal de trabajos
	for w := 1; w <= 4; w++ {
		go worker(w, trabajos, resultados)
	}

	for j := 1; j <= 12; j++ { trabajos <- j }
	close(trabajos) // no habrá más trabajo: los workers terminarán su for range

	for i := 0; i < 12; i++ {
		fmt.Println(<-resultados)
	}
}

// Las flechas en el tipo documentan la dirección: solo-lectura / solo-escritura
func worker(id int, trabajos <-chan int, resultados chan<- string) {
	for j := range trabajos {
		time.Sleep(100 * time.Millisecond) // simular trabajo
		resultados <- fmt.Sprintf("worker %d terminó el trabajo %d", id, j)
	}
}

// Cada etapa recibe un canal y devuelve otro: se componen como tuberías Unix.
// generar(1..n) → cuadrado → filtrarPares → consumir

func generar(n int) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out)
		for i := 1; i <= n; i++ { out <- i }
	}()
	return out
}

func cuadrado(in <-chan int) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out)
		for v := range in { out <- v * v }
	}()
	return out
}

func main() {
	for v := range cuadrado(generar(5)) {
		fmt.Println(v) // 1 4 9 16 25
	}
}

// Fan-out: varias goroutines leen del MISMO canal (reparto automático).
// Fan-in: juntar varios canales en uno solo:
func fanIn[T any](canales ...<-chan T) <-chan T {
	out := make(chan T)
	var wg sync.WaitGroup

	for _, c := range canales {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for v := range c { out <- v }
		}()
	}

	go func() { wg.Wait(); close(out) }()
	return out
}

// El patrón estándar: el mutex vive DENTRO del struct que protege,
// y ningún método sale sin soltar el lock (defer).
type Cache struct {
	mu    sync.RWMutex
	datos map[string]string
}

func (c *Cache) Get(k string) (string, bool) {
	c.mu.RLock()         // muchos lectores a la vez
	defer c.mu.RUnlock()
	v, ok := c.datos[k]
	return v, ok
}

func (c *Cache) Set(k, v string) {
	c.mu.Lock()          // escritor exclusivo
	defer c.mu.Unlock()
	c.datos[k] = v
}

// sync.Once: inicialización perezosa thread-safe (tu singleton bien hecho)
var (
	instancia *Config
	una       sync.Once
)

func ObtenerConfig() *Config {
	una.Do(func() { instancia = cargarConfig() }) // corre EXACTAMENTE una vez
	return instancia
}

// sync/atomic para contadores calientes, sin lock:
var peticiones atomic.Int64
peticiones.Add(1)
fmt.Println(peticiones.Load())