Permulaan Pantas Pengaturcaraan Rangkaian: Pengaturcaraan Serentak dalam Bahasa Go

Permulaan Pantas Pengaturcaraan Rangkaian: Pengaturcaraan Serentak dalam Bahasa Go

Dengan perkembangan Internet, pengaturcaraan rangkaian secara beransur-ansur menjadi salah satu kemahiran yang mesti dikuasai oleh pengaturcara. Pengaturcaraan serentak adalah bahagian yang amat diperlukan dalam pengaturcaraan rangkaian, terutamanya dalam situasi konkurensi yang tinggi. Bahasa Go ialah bahasa pengaturcaraan yang dicirikan oleh pengaturcaraan serentak yang cekap, dan model konkurensinya lebih mudah dan lebih jelas daripada bahasa lain. Artikel ini akan memperkenalkan pengaturcaraan serentak dalam bahasa Go untuk membantu pemula bermula dengan cepat.

1. Goroutine

Goroutine ialah urutan ringan dalam bahasa Go yang dilaksanakan melalui Goroutine. Setiap Goroutine boleh melaksanakan kod yang berbeza secara serentak, dan overhed Goroutine adalah sangat kecil Puluhan ribu Goroutine boleh dibuka dengan mudah tanpa perlu risau tentang penggunaan memori. Penggunaan asas Goroutine adalah sangat mudah. Hanya tambahkan kata kunci pergi sebelum panggilan fungsi untuk memulakan Goroutine.

Sebagai contoh, kita boleh mencipta Goroutine melalui kod berikut:

func main() { go printHello() } func printHello() { fmt.Println("Hello, world!") }

Dalam kod di atas, apabila program Go berjalan untuk pergi printHello(), ia akan memulakan Goroutine baharu untuk dilaksanakan fungsi printHello . Kerana fungsi printHello berjalan secara bebas daripada fungsi utama, program mencetak "Hello, dunia dengan segera!"

2. Saluran

Komunikasi antara Goroutines adalah melalui Saluran. Saluran boleh dilihat sebagai saluran paip antara Goroutines dan boleh digunakan untuk menghantar dan menerima data. Saluran dalam bahasa Go boleh menghantar data secara serentak dan juga boleh digunakan untuk melaksanakan pengaturcaraan tak segerak. Penciptaan dan penggunaan Saluran juga sangat mudah. Hanya gunakan fungsi buat untuk menciptanya, dan kemudian gunakan operator <- untuk menghantar dan menerima data.

Sebagai contoh, kami boleh mencipta Saluran dan menghantar data melalui kod berikut:

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

Dalam kod di atas, kami mencipta Saluran integer dan memulakan Goroutine untuk penghantaran data. Fungsi utama menyekat dan menunggu Saluran menghantar data melalui penyataan <-ch Selepas menerima data, program akan mengeluarkan "1".

Saluran boleh digunakan untuk menghantar data antara berbilang Goroutine, mengelakkan isu penyegerakan yang perlu dipertimbangkan apabila menggunakan memori kongsi. Di samping itu, penyelarasan dan penyegerakan antara berbilang Goroutine boleh dicapai melalui Saluran, dengan itu merealisasikan tugas pengaturcaraan serentak yang kompleks.

3. Pilih

Apabila membaca data daripada berbilang Saluran dalam berbilang Goroutine, anda boleh menggunakan sintaks pilih dalam bahasa Go untuk diproses. Sintaks pilihan adalah serupa dengan sintaks Tukar Ia boleh memantau interaksi data berbilang Saluran Apabila data muncul dalam salah satu Saluran, blok kod yang sepadan akan dicetuskan.

Sebagai contoh, kita boleh mencipta dua Goroutine melalui kod berikut dan menggunakan sintaks pilih untuk memproses bacaan Chanenl:

func main() { ch1 := make(chan int) ch2 := make(chan int) go func() { ch1 <- 1 }() go func() { ch2 <- 2 }() select { case x := <- ch1: fmt.Println("Received from ch1:", x) case x := <- ch2: fmt.Println("Received from ch2:", x) } }

Dalam kod di atas, kami mencipta dua Goroutine untuk menghantar mesej kepada dua Saluran masing-masing. Gunakan pernyataan pilih untuk memantau penghantaran data kedua-dua Saluran Selagi salah satu Saluran menghantar data, blok kod yang sepadan akan dilaksanakan dan data yang diterima akan dikeluarkan.

4. Mutex

Bahasa Go menyokong berbilang urutan untuk mengakses pembolehubah yang sama secara serentak Untuk menyelesaikan masalah ketidakkonsistenan data semasa menulis pembolehubah pada masa yang sama, Go bahasa menyediakan kunci mutex Mutex untuk dikunci. Apabila kita mengubah suai pembolehubah, kita mula-mula membuka kunci melalui kaedah Mutex.Lock() Pada masa ini, hanya satu utas telah memperoleh kunci, dan utas lain akan disekat apabila cuba mendapatkan kunci pada masa ini telah selesai menggunakan pembolehubah, kita perlu menggunakan kaedah Mutex.Unlock() secara manual untuk membuka kunci untuk melepaskan sumber kunci.

Sebagai contoh, kami boleh menunjukkan penggunaan Mutex melalui kod berikut:

import ( "fmt" "sync" "time" ) var wg sync.WaitGroup var mutex sync.Mutex var counter int func main() { for i := 0; i < 10; i++ { wg.Add(1) go increment() } wg.Wait() fmt.Println("Final counter:", counter) } func increment() { mutex.Lock() defer mutex.Unlock() counter++ time.Sleep(time.Second) fmt.Println("Counter value:", counter) wg.Done() }

Dalam kod di atas, kami mencipta 10 Goroutine, setiap Goroutine akan menambah pembolehubah pembilang sebanyak satu. Untuk memastikan ketepatan data, kami menggunakan Mutex untuk melindungi kaunter. Panggil kaedah Mutex.Lock() dalam Goroutine untuk mendapatkan kunci, dan kemudian panggil kaedah Mutex.Unlock() untuk membuka kuncinya selepas operasi. Selepas menggunakan WaitGroup untuk menunggu semua pelaksanaan Goroutine selesai, keluarkan nilai pembilang akhir.

Ringkasan

Pengaturcaraan serentak dalam bahasa Go menggunakan Goroutine dan Channel untuk penghantaran data, menggunakan Mutex untuk menyegerakkan dan melindungi pembolehubah serta menggunakan pilih untuk membaca berbilang Saluran. Dengan menggunakan mekanisme ini secara rasional, kami boleh menulis atur cara serentak yang cekap, jelas dan mudah diselenggara yang memainkan peranan yang berkuasa dalam senario aplikasi serentak tinggi.

Atas ialah kandungan terperinci Permulaan Pantas Pengaturcaraan Rangkaian: Pengaturcaraan Serentak dalam Bahasa Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!