Analisis dokumen bahasa Go: fungsi sync.Cond melaksanakan pembolehubah keadaan

Dalam bahasa Go, pakej penyegerakan menyediakan fungsi alat yang sangat praktikal - sync.Cond. Artikel ini menyediakan analisis terperinci tentang fungsi ini dan menyediakan kod contoh khusus untuk membantu pembaca memahami dan menggunakan fungsi ini dengan lebih baik.

1. Apakah fungsi sync.Cond?

Dalam bahasa Go, fungsi sync.Cond digunakan untuk melaksanakan pembolehubah keadaan. Pembolehubah keadaan ialah mekanisme penyegerakan yang biasa digunakan dalam pengaturcaraan berbilang benang, digunakan untuk mencapai kerjasama antara utas apabila satu atau lebih utas perlu menunggu peristiwa berlaku. Khususnya, apabila syarat tertentu tidak dipenuhi, benang boleh memasuki keadaan tidur dengan menunggu pembolehubah keadaan, dan apabila pembolehubah keadaan dipenuhi, benang lain boleh bekerjasama dengan membangunkan benang menunggu dalam pembolehubah keadaan.

sync.Cond fungsi ditakrifkan seperti berikut:

type Cond struct {
    // contains filtered or unexported fields
}

sync.Cond ialah jenis struktur Memandangkan ia mengandungi medan yang tidak dieksport, ia tidak boleh dimulakan secara langsung. Apabila menggunakannya, kita perlu menggunakan fungsi penyegerakan.NewCond untuk pemulaan Penggunaan khusus adalah seperti berikut:

func NewCond(l Locker) *Cond

Antaranya, l ialah kunci mutex yang digunakan untuk mencapai penyegerakan antara benang. Selepas panggilan permulaan, kita perlu menggunakan tiga kaedah utama Cond - Tunggu, Isyarat dan Siar - untuk mencapai kerjasama antara rangkaian.

2. Kaedah penyegerakan utama.Cond

1. Tunggu

Tunggu kaedah digunakan untuk membuat kaedah semasa benang tunggu pembolehubah keadaan. Khususnya, apabila syarat tertentu tidak dipenuhi, utas boleh memasuki keadaan tidur dengan menunggu pembolehubah keadaan dan menunggu utas lain untuk bangun.

Definasi kaedah ini adalah seperti berikut:

func (c *Cond) Wait()

Apabila menggunakan kaedah Tunggu, kita perlu terlebih dahulu memperoleh kunci mutex, lepaskan kunci sebelum memasuki keadaan menunggu, dan tunggu benang lain Dapatkan semula kunci selepas bangun.

Kod sampel adalah seperti berikut:

package main

import (
    "fmt"
    "sync"
    "time"
)

var (
    wg      sync.WaitGroup
    locker  sync.Mutex
    condVar *sync.Cond
)

func main() {
    condVar = sync.NewCond(&locker)
    wg.Add(2)

    // 等待条件变量
    go func() {
        defer wg.Done()
        fmt.Println("wait for cond")
        condVar.L.Lock()
        condVar.Wait()
        fmt.Println("receive signal")
        condVar.L.Unlock()
    }()

    // 发送信号
    go func() {
        defer wg.Done()
        time.Sleep(2 * time.Second)
        condVar.L.Lock()
        condVar.Signal()
        fmt.Println("send signal")
        condVar.L.Unlock()
    }()

    wg.Wait()
}

Dalam kod di atas, kami mula-mula menggunakan fungsi sync.NewCond untuk memulakan kunci mutex dan condVar pembolehubah keadaan yang sepadan. Kemudian kami menggunakan dua goroutin serentak untuk menunggu pembolehubah keadaan dan menghantar isyarat masing-masing. Selepas menunggu isyarat dihantar, goroutine memperoleh semula kunci dan mengeluarkan maklumat segera yang berkaitan. Proses Go yang menghantar isyarat memperoleh kunci mutex selepas menunggu selama dua saat, dan melepaskan kunci selepas menghantar isyarat kepada pembolehubah keadaan.

Menjalankan kod di atas, kita dapat melihat bahawa atur cara mengeluarkan kandungan berikut:

wait for cond
send signal
receive signal

Ia dapat dilihat bahawa selepas menunggu untuk tempoh masa, goroutine menunggu untuk pembolehubah keadaan melepasi condVar Kaedah .Tunggu memasuki keadaan tidur. Selepas Goroutine penghantar isyarat menghantar isyarat, Goroutine menunggu pembolehubah keadaan dibangkitkan melalui kaedah condVar.Signal, dan maklumat segera yang sepadan dikembalikan.

2. Isyarat

Kaedah Isyarat digunakan untuk membangunkan benang menunggu pembolehubah keadaan. Khususnya, apabila pembolehubah keadaan tertentu berubah, utas boleh membangunkan salah satu utas menunggu pembolehubah keadaan melalui kaedah Isyarat untuk mencapai kerjasama antara utas.

Kaedahnya ditakrifkan seperti berikut:

func (c *Cond) Signal()

Perlu diingatkan bahawa kaedah Isyarat hanya boleh membangunkan benang menunggu pembolehubah keadaan. Jika kita ingin membangunkan beberapa utas, kita boleh menggunakan kaedah Penyiaran.

Kod sampel adalah seperti berikut:

package main

import (
    "fmt"
    "sync"
    "time"
)

var (
    wg      sync.WaitGroup
    locker  sync.Mutex
    condVar *sync.Cond
)

func main() {
    condVar = sync.NewCond(&locker)
    wg.Add(3)

    // 等待条件变量
    go func() {
        defer wg.Done()
        fmt.Println("wait for cond")
        condVar.L.Lock()
        condVar.Wait()
        fmt.Println("receive signal 1")
        condVar.L.Unlock()
    }()

    // 尝试多次等待
    go func() {
        defer wg.Done()
        for i := 0; i < 4; i++ {
            fmt.Printf("wait for cond %d
", i+1)
            condVar.L.Lock()
            condVar.Wait()
            fmt.Printf("receive signal %d
", i+1)
            condVar.L.Unlock()
        }
    }()

    // 发送信号
    go func() {
        defer wg.Done()
        time.Sleep(2 * time.Second)
        condVar.L.Lock()
        condVar.Signal()
        fmt.Println("send signal")
        condVar.L.Unlock()
        time.Sleep(2 * time.Second)
        condVar.L.Lock()
        condVar.Broadcast()
        fmt.Println("broadcast signal")
        condVar.L.Unlock()
    }()

    wg.Wait()
}

Dalam kod di atas, kami menggunakan tiga goroutin serentak untuk menunggu pembolehubah keadaan dan menghantar isyarat masing-masing. Salah satu goroutine menggunakan kaedah Tunggu untuk menunggu pembolehubah keadaan, manakala goroutine yang lain cuba menunggu beberapa kali sehingga isyarat diterima. Goroutine ketiga mula-mula menghantar isyarat selepas menunggu selama dua saat, dan kemudian menunggu selama dua saat dan kemudian menghantar isyarat siaran semula.

Menjalankan kod di atas, kita dapat melihat bahawa program mengeluarkan kandungan berikut:

wait for cond
wait for cond 1
wait for cond 2
wait for cond 3
send signal
receive signal 1
wait for cond 4
broadcast signal
receive signal 2
receive signal 3
receive signal 4

Ia dapat dilihat bahawa proses Pergi menunggu pembolehubah keadaan mula-mula dibangkitkan dan mengembalikan maklumat Gesaan yang sepadan. Goroutine yang kemudiannya cuba menunggu beberapa kali menunggu dan menerima isyarat masing-masing. Akhir sekali, selepas menghantar isyarat siaran, semua Goroutine yang menunggu pembolehubah keadaan dibangkitkan dan maklumat segera yang sepadan dikembalikan.

3. Ringkasan

Artikel ini memperkenalkan secara ringkas definisi dan kaedah utama fungsi penyegerakan.Cond dalam bahasa Go, menyediakan analisis terperinci tentang penggunaan sebenar dan memberikan Spesifik kod sampel. Apabila melakukan pengaturcaraan berbilang benang, perlu menggunakan pembolehubah keadaan secara rasional. Oleh itu, menguasai penggunaan fungsi sync.Cond sangat membantu dalam meningkatkan keselamatan dan kebolehpercayaan kod.

Atas ialah kandungan terperinci Analisis dokumen bahasa Go: fungsi sync.Cond melaksanakan pembolehubah keadaan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!