Beberapa teknik biasa dan pengalaman praktikal dalam penulisan serentak di Golang

Dengan perkembangan berterusan teknologi komputer, keselarasan tinggi telah menjadi topik yang sangat penting dalam pembangunan perisian moden. Sebagai bahasa pengaturcaraan serentak, Golang (pendek kata) mempunyai kaedah penulisan serentak yang sangat bagus untuk menangani masalah konkurensi yang tinggi. Artikel ini akan memperkenalkan beberapa teknik biasa dan pengalaman praktikal penulisan serentak di Golang.

1. Goroutine

Goroutine ialah benang ringan di Golang yang boleh melaksanakan berbilang tugas serentak dalam satu proses. Menggunakan Goroutine membolehkan kami mengendalikan tugas serentak dengan mudah tanpa perlu mengurus berbilang benang dan mekanisme kunci secara manual. Untuk memulakan Goroutine di Golang, anda hanya perlu menambah kata kunci pergi sebelum fungsi, contohnya:

func main() {
    go worker()
}

func worker() {
    // do something
}

Dalam kod di atas, kami menggunakan kata kunci go dalam fungsi utama untuk memulakan Goroutine bagi fungsi pekerja. Apabila fungsi utama menyelesaikan pelaksanaan, Goroutine akan berhenti secara automatik. Permulaan dan penghentian Goroutine adalah sangat ringan, jadi kami boleh memulakan sejumlah besar Goroutine pada masa yang sama untuk mengendalikan tugas serentak.

2. Saluran

Saluran ialah mekanisme komunikasi di Golang yang boleh menghantar data antara Goroutines. Menggunakan Saluran boleh mengelakkan persaingan dan isu perkongsian data antara berbilang Goroutine. Untuk membuat Saluran di Golang, anda hanya perlu menggunakan fungsi buat, contohnya:

ch := make(chan int)

Dalam kod di atas, kami mencipta Saluran dengan jenis komunikasi int. Anda boleh menggunakan operator <- untuk menghantar data ke Saluran, contohnya:

ch <- 10

Dalam kod di atas, kami menghantar integer 10 ke Saluran. Anda boleh menggunakan operator <- untuk menerima data Saluran, contohnya:

x := <-ch

Dalam kod di atas, kami menerima integer daripada Saluran dan menetapkannya kepada pembolehubah x. Menggunakan Saluran dalam Goroutine yang berbeza membolehkan kerjasama yang mudah dan mengelakkan masalah persaingan dan penyegerakan.

3. Mutex

Mutex ialah kunci mutex di Golang, yang boleh digunakan untuk mengelakkan masalah persaingan antara berbilang Goroutine. Untuk mencipta Mutex dalam Golang, anda hanya perlu menggunakan pakej penyegerakan, contohnya:

var mu sync.Mutex

Dalam kod di atas, kami mengisytiharkan pembolehubah mutex mu. Dalam blok kod yang perlu melindungi sumber kongsi, anda boleh menggunakan fungsi Kunci dan Buka Kunci untuk memperoleh dan melepaskan kunci masing-masing, contohnya:

mu.Lock()
// do something with shared resource
mu.Unlock()

Dalam kod di atas, kami memperoleh kunci sebelum memasukkan kunci yang dikongsi blok kod sumber, Ini mengelakkan masalah persaingan antara berbilang Goroutines. Menggunakan Mutex boleh memastikan keselamatan sumber yang dikongsi, tetapi ia juga akan mengurangkan prestasi program kerana ia memerlukan penguncian dan buka kunci yang kerap.

4. WaitGroup

WaitGroup ialah kumpulan menunggu di Golang yang boleh menunggu beberapa Goroutine selesai sebelum meneruskan. Untuk membuat WaitGroup di Golang, anda hanya perlu menggunakan pakej penyegerakan, contohnya:

var wg sync.WaitGroup

Dalam kod di atas, kami mengisytiharkan pembolehubah kumpulan menunggu wg. Dalam kod yang perlu menunggu beberapa pelaksanaan Goroutine selesai sebelum meneruskan, anda boleh menggunakan fungsi Tambah dan Selesai untuk menambah dan melepaskan pembilang kumpulan menunggu masing-masing, contohnya:

wg.Add(1)
go worker(&wg)

// ...

wg.Wait()

Dalam kod di atas, kita menggunakan fungsi Tambah untuk menambah dan melepaskan kaunter kumpulan menunggu ditambah dengan satu Selepas pelaksanaan dalam fungsi pekerja selesai, gunakan fungsi Selesai untuk mengurangkan kaunter kumpulan menunggu dengan satu untuk memastikan pelaksanaannya. selesai. Pada fungsi Tunggu, program akan menunggu semua fungsi Pekerja selesai sebelum melaksanakan langkah seterusnya. Menggunakan WaitGroup boleh mengelakkan masalah persaingan antara berbilang Goroutine dan memastikan penyegerakan tugas serentak.

5. Pilih

Pilih ialah pemilih dalam Golang yang boleh digunakan untuk memultiplekskan Saluran. Menggunakan Pilih dalam Golang boleh mengendalikan kerjasama dan komunikasi antara tugas serentak dengan mudah. Dalam Select, anda boleh menggunakan pernyataan bersyarat kes untuk mengesan sama ada data Saluran tersedia, contohnya:

select {
case x := <-ch1:
    // handle x from ch1
case y := <-ch2:
    // handle y from ch2
default:
    // do something else
}

Dalam kod di atas, kami menggunakan Select untuk mengesan sama ada data daripada ch1 dan ch2 tersedia dan memproses mereka masing-masing. Pernyataan lalai boleh digunakan untuk mengendalikan situasi apabila tiada data tersedia. Gunakan Pilih untuk mengendalikan komunikasi dan kerjasama dengan mudah antara berbilang tugas serentak.

Kesimpulan

Di Golang, menggunakan ciri konkurensi seperti Goroutine, Channel, Mutex, WaitGroup dan Select boleh menangani masalah konkurensi tinggi dengan mudah. Pengalaman praktikal menggabungkan ciri ini boleh membantu kami mengendalikan tugas serentak dengan lebih baik. Sudah tentu, penggunaan ciri konkurensi yang betul juga memerlukan perhatian untuk mengelakkan kebuntuan, keadaan perlumbaan dan isu lain untuk memastikan ketepatan dan prestasi program.

Atas ialah kandungan terperinci Beberapa teknik biasa dan pengalaman praktikal dalam penulisan serentak di Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!