errgroup & pola concurrency praktis

Setelah goroutine, channel, dan mutex, yang tersisa adalah merangkainya jadi pola yang berulang. Empat pola berikut menutupi hampir semua kebutuhan concurrency di aplikasi web.

Pola 1: fan-out — beberapa panggilan sekaligus

import "golang.org/x/sync/errgroup"

func (s *Layanan) Dasbor(ctx context.Context, uid int64) (Dasbor, error) {
	var (
		profil   Profil
		pesanan  []Pesanan
		notif    int
	)

	g, ctx := errgroup.WithContext(ctx)

	g.Go(func() (err error) {
		profil, err = s.profil.Ambil(ctx, uid)
		return err
	})
	g.Go(func() (err error) {
		pesanan, err = s.pesanan.Terbaru(ctx, uid, 5)
		return err
	})
	g.Go(func() (err error) {
		notif, err = s.notif.Hitung(ctx, uid)
		return err
	})

	if err := g.Wait(); err != nil {
		return Dasbor{}, err
	}
	return Dasbor{Profil: profil, Pesanan: pesanan, Notifikasi: notif}, nil
}

Pola 2: batas paralelisme

g, ctx := errgroup.WithContext(ctx)
g.SetLimit(10)          // maksimal 10 goroutine berjalan bersamaan

for _, url := range daftarURL {
	g.Go(func() error {
		return unduh(ctx, url)
	})
}
if err := g.Wait(); err != nil { ... }

Satu baris SetLimit menggantikan seluruh worker pool manual dari materi channel. Angkanya bukan tebakan — ia diturunkan dari sumber daya yang paling terbatas:

Pola 3: yang tercepat menang

// Dua sumber, ambil yang duluan menjawab. Cocok untuk cache + database.
func ambilCepat(ctx context.Context, id int64) (Produk, error) {
	ctx, batal := context.WithCancel(ctx)
	defer batal()                       // menghentikan yang kalah

	type hasil struct {
		p   Produk
		err error
	}
	ch := make(chan hasil, 2)           // BERBUFFER: yang kalah tidak bocor

	go func() { p, err := dariCache(ctx, id); ch <- hasil{p, err} }()
	go func() { p, err := dariDB(ctx, id);    ch <- hasil{p, err} }()

	var terakhir error
	for range 2 {
		h := <-ch
		if h.err == nil {
			return h.p, nil
		}
		terakhir = h.err
	}
	return Produk{}, terakhir
}

Pola 4: singleflight — menggabungkan permintaan kembar

import "golang.org/x/sync/singleflight"

type Layanan struct {
	grup  singleflight.Group
	cache *redis.Client
}

func (s *Layanan) Ambil(ctx context.Context, id int64) (Produk, error) {
	kunci := fmt.Sprintf("produk:%d", id)

	v, err, _ := s.grup.Do(kunci, func() (any, error) {
		// Hanya SATU goroutine masuk ke sini per kunci, berapa pun
		// jumlah pemanggil bersamaan. Sisanya menunggu hasilnya.
		return s.dariDB(ctx, id)
	})
	if err != nil {
		return Produk{}, err
	}
	return v.(Produk), nil
}

Pola yang sebaiknya kamu hindari