Bagaimana untuk melaksanakan kebuntuan di Golang? Bagaimana untuk mengelakkannya?

Golang ialah bahasa pengaturcaraan yang cekap, ditaip kuat dan statik yang dibangunkan oleh Google untuk menyelesaikan masalah seperti kebuntuan. Walaupun sangat sukar untuk melaksanakan kebuntuan di Golang, dalam artikel ini, kita akan meneroka bagaimana untuk melaksanakan kebuntuan menggunakan Golang.

Apakah kebuntuan?

Kebuntuan merujuk kepada situasi apabila berbilang proses atau utas meminta sumber, mereka menunggu antara satu sama lain, menyebabkan semua proses atau urutan tidak dapat meneruskan pelaksanaan. Dalam senario konkurensi tinggi, masalah kebuntuan adalah sangat biasa.

Di Golang, ia adalah cara yang sangat biasa untuk menggunakan saluran untuk berkomunikasi antara coroutine. Walau bagaimanapun, jika saluran antara coroutine digunakan secara tidak wajar, ia boleh menyebabkan masalah kebuntuan dengan mudah.

Bagaimana untuk melaksanakan kebuntuan?

Kod berikut ialah contoh mudah. Apabila dua goroutine berkomunikasi antara satu sama lain menggunakan saluran, masalah kebuntuan berlaku.

package main

import (
    "fmt"
)

func main() {
    fmt.Println("Start.....")
    ch := make(chan int)
    ch <- 1
    fmt.Println(<-ch)
}

Memandangkan saluran digunakan untuk komunikasi antara coroutine, apabila saluran menghantar atau menerima data, coroutine semasa akan disekat.

Dalam kod ini, terdapat saluran ch, yang mula-mula menghantar data 1 ke saluran, dan kemudian menerima data 1 yang sama daripada saluran. Walau bagaimanapun, memandangkan operasi penerimaan saluran mesti menunggu operasi penghantaran saluran, program akan disekat, mengakibatkan masalah kebuntuan.

Bagaimana untuk mengelakkan kebuntuan?

Untuk mengelakkan masalah kebuntuan, anda secara umumnya boleh menanganinya dengan cara berikut:

1. Kawal susunan penghantaran dan penerimaan saluran untuk memastikan coroutine tidak menunggu antara satu sama lain.
2. Sebelum menggunakan saluran, tentukan sama ada saluran telah ditutup. Jika saluran telah ditutup, jangan hantar data ke saluran, jika tidak, masalah kebuntuan mungkin berlaku dengan mudah.
3. Gunakan penyataan pilih untuk memantau berbilang saluran, supaya anda boleh mengundi secara berterusan dan mengelakkan masalah kebuntuan dalam keseluruhan program kerana menunggu saluran tertentu.

Berikut ialah contoh untuk mengelakkan kebuntuan:

package main

import (
    "fmt"
)

func main() {
    fmt.Println("Start.....")
    ch := make(chan int)
    go func() {
        for {
            select {
            case v := <-ch:
                fmt.Println("Receive value from channel:", v)
            default:
                fmt.Println("No value receive from channel.")
            }
        }
    }()
    ch <- 1
}

Dalam kod ini, kami menggunakan blok pilih untuk memantau saluran ch. Jika terdapat nilai dalam saluran ch, maka Nilai dalam saluran akan diterima, jika tidak gesaan "tiada nilai diterima daripada saluran" akan dikeluarkan.

Dengan cara ini, program tidak akan menemui jalan buntu sepanjang program kerana menunggu saluran tertentu.

Ringkasan

Di Golang, walaupun sukar untuk mencapai kebuntuan, kami boleh menggunakan saluran dengan munasabah, mengawal susunan penghantaran dan penerimaan saluran, tentukan sama ada saluran telah ditutup, dan gunakan Pilih kenyataan digunakan untuk memantau saluran dan kaedah lain untuk mengelakkan masalah kebuntuan dengan berkesan. Kemahiran ini amat penting dalam senario berkonkurensi tinggi. Saya harap pembaca dapat menguasai kemahiran ini dan menerapkannya dalam pembangunan sebenar.

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan kebuntuan di Golang? Bagaimana untuk mengelakkannya?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!