Komunikasi antara proses dan teknik penyegerakan Goroutine untuk fungsi Golang

Di Golang, goroutine ialah benang ringan dengan keupayaan pemprosesan serentak yang berkuasa. Fungsi ialah struktur pengaturcaraan asas di Golang Ia digunakan secara meluas dalam pembangunan dan juga merupakan alat penting untuk komunikasi dan penyegerakan antara goroutine. Artikel ini akan memperkenalkan beberapa teknik komunikasi antara proses dan penyegerakan goroutine untuk fungsi Golang untuk membantu pembangun Golang menggunakan teknologi ini dengan lebih baik.

1. Saluran

Saluran ialah salah satu alat asas dalam pengaturcaraan serentak Golang Ia boleh digunakan untuk komunikasi dan penyegerakan antara goroutine. Saluran dicipta oleh make dan mempunyai jenis dan kapasiti. Kapasiti saluran menunjukkan jumlah data yang boleh ditimbal Jika kapasiti adalah 0, ia bermakna ia adalah saluran yang tidak dibuffer dan hanya boleh digunakan untuk tujuan penyegerakan.

Menggunakan saluran Golang adalah sangat mudah, hanya gunakan operator <- untuk menghantar dan menerima mesej. Contohnya:

ch := make(chan int, 10) // 创建具有10个缓冲区的通道

go func(ch chan int) {
    for i := 0; i < 10; i++ {
        ch <- i
    }
    close(ch) // 关闭通道
}(ch)

for value := range ch {
    fmt.Println(value)
}

Kod di atas mencipta saluran dengan 10 penimbal, kemudian memulakan goroutine untuk menghantar nilai dari 0 hingga 9 ke saluran dan menutup saluran selepas menghantar. Kemudian gunakan julat untuk melintasi saluran dan teruskan membaca data daripadanya sehingga saluran ditutup.

2. Mutex (mutex)

Di Golang, pembolehubah boleh diakses oleh berbilang goroutine pada masa yang sama, menyebabkan keadaan perlumbaan. Untuk mengelakkan ini, kita perlu menggunakan mutex untuk melindungi pembolehubah yang dikongsi. Mutex ialah mekanisme penyegerakan di Golang, yang boleh digunakan untuk memastikan hanya satu goroutine boleh mengakses sumber yang dikongsi pada bila-bila masa.

Kunci mutex Golang dilaksanakan dalam pakej penyegerakan, dan penggunaannya juga sangat mudah Anda hanya perlu memanggil kaedah Lock() dan Unlock(). Contohnya:

var counter int
var mutex sync.Mutex

func main() {
    for i := 0; i < 10; i++ {
        go func() {
            for j := 0; j < 100; j++ {
                mutex.Lock() // 加锁
                counter++
                mutex.Unlock() // 解锁
            }
        }()
    }

    time.Sleep(time.Second)
    fmt.Println(counter)
}

Kod di atas memulakan 10 goroutine, dan setiap goroutine akan melakukan 100 operasi pembilang++. Gunakan mutex untuk melindungi pembolehubah pembilang untuk memastikan bahawa hanya satu goroutine boleh mengubah suainya pada satu masa. Gunakan fungsi time.Sleep untuk menunggu semua goroutine selesai melaksanakan, dan akhirnya mencetak nilai pembilang.

3. Pembolehubah keadaan (cond)

Pembolehubah keadaan ialah mekanisme penyegerakan dalam Golang Ia digunakan bersama kunci mutex dan boleh digunakan untuk menunggu peristiwa tertentu berlaku, atau untuk tunggu Ketersediaan sumber tertentu. Pembolehubah keadaan boleh digunakan untuk menyelaraskan operasi penyegerakan antara berbilang gorouti, yang membolehkan gorouti menunggu keadaan tertentu menjadi benar sebelum meneruskan pelaksanaan.

Pembolehubah keadaan Golang dilaksanakan dalam pakej penyegerakan, dan penggunaannya juga sangat mudah Anda hanya perlu memanggil kaedah Wait(), Signal() dan Broadcast(). Contohnya:

var (
    mutex sync.Mutex
    cond  *sync.Cond
)

func producer(ch chan<- int) {
    for i := 0; i < 10; i++ {
        ch <- i
    }
    close(ch)
}

func consumer(ch <-chan int) {
    for {
        mutex.Lock()
        if len(ch) == 0 {
            cond.Wait() // 等待条件变量
        }
        value := <-ch
        fmt.Println(value)
        mutex.Unlock()
    }
}

func main() {
    ch := make(chan int, 5)

    mutex.Lock()
    cond = sync.NewCond(&mutex)
    go producer(ch)
    go consumer(ch)
    mutex.Unlock()

    time.Sleep(time.Second)
    mutex.Lock()
    cond.Signal() // 唤醒一个等待的goroutine
    mutex.Unlock()
}

Kod di atas mencipta saluran dengan penimbal, dan kemudian memulakan goroutine pengeluar dan goroutine pengguna. Goroutine pengguna membaca satu nilai dari saluran setiap kali dan mengeluarkannya. Jika saluran kosong, goroutine pengguna akan memanggil kaedah Wait() bagi pembolehubah keadaan dan kemudian tunggu untuk dibangkitkan. Goroutine pengeluar akan terus menulis data ke saluran Apabila data ditulis, ia akan memanggil kaedah Signal() pembolehubah keadaan untuk membangunkan goroutine menunggu.

Ringkasan

Di Golang, fungsi ialah struktur pengaturcaraan yang penting, yang boleh digunakan untuk komunikasi dan penyegerakan antara goroutine. Saluran, mutex dan pembolehubah keadaan biasanya digunakan fungsi Golang untuk komunikasi antara proses dan teknik penyegerakan goroutine menyediakan mekanisme serentak yang kaya dan boleh membantu kami mengurus gelagat goroutine dengan lebih baik. Pada masa yang sama, kita juga perlu memberi perhatian kepada isu-isu yang terlibat dalam pengaturcaraan serentak, seperti keadaan perlumbaan, kebuntuan, dan lain-lain, untuk memastikan ketepatan dan kecekapan program.

Atas ialah kandungan terperinci Komunikasi antara proses dan teknik penyegerakan Goroutine untuk fungsi Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!