Cara membuat golang asynchronous

Kaedah asynchronous Golang: 1. Mod permintaan/tindak balas serentak, di mana satu goroutine menghantar permintaan ke goroutine lain, dan kemudian menunggu respons 2. Di mana berbilang goroutine menerima data dari satu saluran, dan menghantar hasilnya kepada yang lain selepas saluran pemprosesan.

Persekitaran pengendalian tutorial ini: sistem Windows 10, golang versi 1.20.1, komputer DELL G3.

Golang ialah bahasa pengaturcaraan yang berkuasa dan cekap Ia menyediakan mekanisme pengaturcaraan serentak yang kaya, salah satu ciri pentingnya ialah pengaturcaraan tak segerak. Pengaturcaraan tak segerak boleh membantu pembangun meningkatkan prestasi dan kebolehskalaan program sambil memberikan pengalaman pengguna yang lebih baik. Dalam artikel ini, kita akan membincangkan cara melaksanakan pengaturcaraan tak segerak di Golang.

Di Golang, pengaturcaraan tak segerak boleh dilaksanakan melalui goroutin dan saluran. Goroutine ialah benang ringan yang boleh dijalankan dalam persekitaran pelaksanaan serentak, dan saluran ialah saluran paip yang digunakan untuk komunikasi antara goroutine.

1. Mari kita perkenalkan goroutine. Goroutine ialah benang ringan yang diuruskan oleh persekitaran masa jalan bahasa Go. Menggunakan goroutine, anda boleh menjalankan berbilang fungsi secara serentak dalam program tanpa membuat utas tambahan. Mulakan goroutine dengan menggunakan kata kunci go, contohnya:

gofuncName()

Dalam contoh di atas, funcName ialah nama fungsi dan dengan memanggil kata kunci go, fungsi itu akan dilaksanakan secara tak segerak dalam goroutine baharu. Menggunakan goroutine membolehkan program melaksanakan pelbagai fungsi pada masa yang sama, meningkatkan prestasi serentak program.

2. Jom tengok saluran. Saluran adalah jambatan untuk komunikasi antara goroutine. Ia boleh digunakan untuk menghantar dan menerima nilai, sekali gus membolehkan penyegerakan antara gorouti yang berbeza. Di Golang, anda boleh menggunakan fungsi make untuk membuat saluran, contohnya:

ch:=make(chandataType)

Dalam contoh di atas, dataType ialah jenis data yang boleh diterima oleh saluran. Penyegerakan antara goroutine boleh dicapai menggunakan saluran, contohnya:

ch<-value//发送数据到channel
result:=<-ch//从channel接收数据

Dalam contoh di atas, ch <- nilai bermaksud menghantar nilai ke saluran, dan <-ch bermaksud menerima data daripada saluran. Saluran boleh digunakan untuk mencapai penyegerakan dan pemindahan data antara dua atau lebih goroutine.

3 Kami akan memperkenalkan beberapa corak pengaturcaraan tak segerak biasa. Yang pertama ialah pola permintaan/tindak balas serentak, di mana satu goroutine menghantar permintaan kepada goroutine lain dan kemudian menunggu respons. Ini boleh dicapai menggunakan goroutine dan saluran, contohnya:

funcworker(requestchanint,responsechanint){
for{
req:=<-request//从channel接收请求
//处理请求
result:=req*2//假设这是一个耗时的操作
response<-result//发送响应到channel
}
}
funcmain(){
request:=make(chanint)
response:=make(chanint)
goworker(request,response)
//发送请求
request<-10
//等待响应
result:=<-response
fmt.Println(result)//输出20
}

Dalam contoh di atas, fungsi pekerja menerima dua saluran, permintaan dan tindak balas, sebagai parameter. Ia menggunakan gelung tak terhingga untuk mendengar permintaan saluran, dan mengendalikan permintaan. Hasilnya kemudian dihantar ke saluran respons. Fungsi utama mencipta permintaan dan tindak balas saluran, dan memulakan goroutine fungsi pekerja. Fungsi utama menghantar 10 untuk meminta saluran, kemudian tunggu maklum balas pekerja dan cetak hasilnya.

Satu lagi corak biasa ialah corak kipas keluar/masuk, di mana berbilang goroutin menerima data daripada satu saluran dan menghantar hasilnya ke saluran lain selepas diproses. Ini boleh membantu meningkatkan kelajuan pemprosesan dan pemprosesan program, contohnya:

funcworker(inputchanint,outputchanint){
for{
data:=<-input//从channel接收数据
//处理数据
result:=data*2//假设这是一个耗时的操作
output<-result//发送结果到channel
}
}
funcmain(){
input:=make(chanint)
output:=make(chanint)
fori:=0;i<10;i++{
goworker(input,output)
}
//发送数据
fori:=0;i<10;i++{
input<-i
}
//等待处理结果
fori:=0;i<10;i++{
result:=<-output
fmt.Println(result)
}
}

Dalam contoh di atas, fungsi pekerja menerima data daripada saluran input dan menghantar hasilnya kepada output selepas pemprosesan saluran. Fungsi Utama mencipta input dan output saluran, dan memulakan 10 gorout pekerja. Fungsi utama menghantar data dari 0 hingga 9 ke input saluran dan tunggu hasil pemprosesan. Hasil pemprosesan akan diterima daripada saluran keluaran dan dicetak.

Selain menggunakan goroutine dan saluran, Golang juga menyediakan beberapa mekanisme kawalan dan penyegerakan serentak lain, seperti kunci mutex (sync.Mutex), pembolehubah keadaan (sync.Cond), operasi atom (atom), dll. Mekanisme ini boleh membantu pembangun mengurus akses serentak dan mengendalikan sumber yang dikongsi dengan berkesan.

Dalam aplikasi sebenar, penggunaan pengaturcaraan tak segerak yang betul boleh meningkatkan prestasi dan kebolehskalaan program dengan ketara. Pembangun harus memilih mod konkurensi yang sesuai mengikut situasi sebenar, dan berhati-hati menangani isu akses serentak dan sumber yang dikongsi.

Ringkasnya, Golang menyediakan mekanisme pengaturcaraan serentak yang berkuasa, yang mana pengaturcaraan tak segerak merupakan salah satu ciri utama. Dengan menggunakan goroutine dan saluran, pengaturcaraan tak segerak dan kawalan konkurensi boleh dilaksanakan dengan mudah. Dalam aplikasi sebenar, pembangun harus memilih mod konkurensi yang sesuai mengikut situasi sebenar untuk meningkatkan prestasi dan kebolehskalaan program .

Atas ialah kandungan terperinci Cara membuat golang asynchronous. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!