Go Concurrency: Mutexes vs Channels dengan Contoh

Penyegerakan balas dalam pengaturcaraan serentak Go: Mutex, saluran buffer dan saluran tidak buffer

Apabila membina aplikasi serentak dalam Go, penyegerakan adalah penting untuk memastikan akses selamat kepada data kongsi. Mutex dan Channel ialah alatan utama untuk penyegerakan dalam Go.

Artikel ini meneroka beberapa cara untuk membina kaunter serentak yang selamat. Walaupun artikel rujukan menyelesaikan masalah ini menggunakan Mutex, kami juga akan meneroka alternatif menggunakan saluran penimbal dan tidak penimbal.

Huraian Masalah

Kita perlu membina kaunter yang boleh digunakan dengan selamat serentak.

Kod balas

<code class="language-go">package main

type Counter struct {
    count int
}

func (c *Counter) Inc() {
    c.count++
}

func (c *Counter) Value() int {
    return c.count
}</code>

Untuk memastikan konkurensi kod kami selamat, mari tulis beberapa ujian.

1. Gunakan Mutex

Mutex (mutex) ialah primitif penyegerakan yang memastikan hanya satu goroutine boleh mengakses bahagian kritikal kod pada satu masa. Ia menyediakan mekanisme penguncian: apabila goroutine mengunci Mutex, goroutin lain yang cuba menguncinya akan disekat sehingga Mutex dibuka kuncinya. Oleh itu, ia sering digunakan apabila pembolehubah atau sumber yang dikongsi perlu dilindungi daripada keadaan perlumbaan.

<code class="language-go">package main

import (
    "sync"
    "testing"
)

func TestCounter(t *testing.T) {
    t.Run("using mutexes and wait groups", func(t *testing.T) {
        counter := Counter{}
        wantedCount := 1000

        var wg sync.WaitGroup
        var mut sync.Mutex

        wg.Add(wantedCount)

        for i := 0; i < wantedCount; i++ {
            go func() {
                defer wg.Done()
                mut.Lock()
                counter.Inc()
                mut.Unlock()
            }()
        }

        wg.Wait()
        if counter.Value() != wantedCount {
            t.Errorf("got %d, want %d", counter.Value(), wantedCount)
        }
    })
}</code>

Kod menggunakan sync.WaitGroup untuk menjejaki penyiapan semua goroutin dan menggunakan sync.Mutex untuk menghalang berbilang goroutin daripada mengakses kaunter kongsi pada masa yang sama.

2. Gunakan saluran penimbal

Saluran ialah cara untuk Go membenarkan goroutine berkomunikasi dengan selamat. Mereka dapat memindahkan data antara goroutine dan menyediakan penyegerakan dengan mengawal akses kepada data yang diluluskan.

Dalam contoh ini, kami akan menggunakan saluran untuk menyekat goroutine dan membenarkan hanya satu goroutine mengakses data yang dikongsi. Saluran penimbal mempunyai kapasiti tetap, bermakna ia boleh menyimpan bilangan elemen yang dipratentukan sebelum menyekat pengirim. Pengirim hanya akan menyekat apabila penimbal penuh.

<code class="language-go">package main

import (
    "sync"
    "testing"
)

func TestCounter(t *testing.T) {
    t.Run("using buffered channels and wait groups", func(t *testing.T) {
        counter := Counter{}
        wantedCount := 1000

        var wg sync.WaitGroup
        wg.Add(wantedCount)

        ch := make(chan struct{}, 1)

        ch <- struct{}{} // 允许第一个 goroutine 开始

        for i := 0; i < wantedCount; i++ {
            go func() {
                defer wg.Done()
                <-ch
                counter.Inc()
                ch <- struct{}{}
            }()
        }

        wg.Wait()
        if counter.Value() != wantedCount {
            t.Errorf("got %d, want %d", counter.Value(), wantedCount)
        }
    })
}</code>

Kod menggunakan saluran penimbal dengan kapasiti 1, membenarkan hanya satu goroutine mengakses kaunter pada satu masa.

3. Gunakan saluran bukan penimbal

Saluran tidak buffer tidak mempunyai penimbal. Mereka menyekat penghantar sehingga penerima bersedia untuk menerima data. Ini menyediakan penyegerakan yang ketat, di mana data dihantar antara goroutine satu demi satu.

<code class="language-go">package main

import (
    "sync"
    "testing"
)

func TestCounter(t *testing.T) {
    t.Run("using unbuffered channels and wait groups", func(t *testing.T) {
        counter := Counter{}
        wantedCount := 1000

        var wg sync.WaitGroup
        wg.Add(wantedCount)

        ch := make(chan struct{})

        go func() {
            for i := 0; i < wantedCount; i++ {
                ch <- struct{}{}
            }
            close(ch)
        }()

        for range ch {
            counter.Inc()
            wg.Done()
        }

        if counter.Value() != wantedCount {
            t.Errorf("got %d, want %d", counter.Value(), wantedCount)
        }
    })
}
</code>

Kod menggunakan saluran tidak buffer untuk memastikan hanya satu goroutine mengakses kaunter pada satu masa.

4. Gunakan saluran penimbal dan bukannya WaitGroup

Kami juga boleh menggunakan saluran buffer tanpa WaitGroup, contohnya menggunakan gelung tak terhingga atau saluran lain untuk menjejaki penyiapan goroutine.

Kesimpulan

Artikel ini meneroka pendekatan yang berbeza untuk membina kaunter serentak yang selamat di Go. Mengetahui alatan ini dan masa untuk menggunakannya adalah kunci untuk menulis program Go serentak yang cekap dan selamat.

Sumber Rujukan

Artikel ini diilhamkan oleh bab penyegerakan dalam "Belajar Pergi dengan ujian".

Semoga artikel ini membantu anda!

Atas ialah kandungan terperinci Go Concurrency: Mutexes vs Channels dengan Contoh. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!