Concurrency ialah salah satu ciri penentu Go, menjadikannya bahasa yang hebat untuk membina aplikasi berskala dan berprestasi tinggi. Dalam siaran ini, kami akan meneroka Groutines, yang membolehkan anda menjalankan fungsi serentak dalam Go, memberikan aplikasi anda peningkatan kecekapan yang serius. Sama ada anda bekerja pada pelayan web, pemproses data atau apa-apa jenis aplikasi lain, Goroutines boleh membantu anda melakukan lebih banyak dengan kurang.
Ini perkara yang akan kami bincangkan:
Jom mulakan! ?
Groutine ialah utas ringan yang diuruskan oleh masa jalan Go, membolehkan anda menjalankan fungsi secara serentak. Tidak seperti benang peringkat OS, Goroutines jauh lebih murah dan lebih cekap. Anda boleh melahirkan ribuan Goroutine tanpa membebankan sistem anda, menjadikannya sesuai untuk tugasan serentak.
Membuat Goroutine adalah sangat mudah: hanya gunakan kata kunci go sebelum panggilan fungsi. Mari lihat contoh pantas.
package main
import (
"fmt"
"time"
)
func printMessage(message string) {
for i := 0; i < 5; i++ {
fmt.Println(message)
time.Sleep(500 * time.Millisecond)
}
}
func main() {
go printMessage("Hello from Goroutine!") // This runs concurrently
printMessage("Hello from main!")
}
Dalam contoh ini, printMessage dipanggil sebagai Goroutine dengan go printMessage("Hello from Goroutine!"), yang bermaksud ia akan dijalankan serentak dengan fungsi utama.
Memandangkan Goroutines berjalan serentak, mereka boleh menamatkan dalam sebarang susunan. Untuk memastikan semua Goroutine selesai sebelum meneruskan, anda boleh menggunakan WaitGroup daripada pakej penyegerakan Go.
package main
import (
"fmt"
"sync"
"time"
)
func printMessage(message string, wg *sync.WaitGroup) {
defer wg.Done() // Notify WaitGroup that the Goroutine is done
for i := 0; i < 5; i++ {
fmt.Println(message)
time.Sleep(500 * time.Millisecond)
}
}
func main() {
var wg sync.WaitGroup
wg.Add(1)
go printMessage("Hello from Goroutine!", &wg)
wg.Add(1)
go printMessage("Hello again!", &wg)
wg.Wait() // Wait for all Goroutines to finish
fmt.Println("All Goroutines are done!")
}
Di sini, kami menambahkan wg.Add(1) untuk setiap Goroutine dan memanggil wg.Done() apabila Goroutine selesai. Akhir sekali, wg.Wait() menjeda fungsi utama sehingga semua Goroutines selesai.
Saluran ialah cara terbina dalam Go untuk Goroutines berkomunikasi. Mereka membenarkan anda menghantar data dengan selamat antara Goroutines, memastikan tiada perlumbaan data berlaku.
package main
import (
"fmt"
)
func sendData(channel chan string) {
channel <- "Hello from the channel!"
}
func main() {
messageChannel := make(chan string)
go sendData(messageChannel)
message := <-messageChannel // Receive data from the channel
fmt.Println(message)
}
Dalam contoh ini, sendData menghantar mesej ke messageChannel dan fungsi utama menerimanya. Saluran membantu menyegerakkan Goroutines dengan menyekat sehingga kedua-dua pengirim dan penerima bersedia.
Anda juga boleh mencipta saluran penimbal yang membenarkan bilangan nilai yang ditetapkan disimpan dalam saluran sebelum ia disekat. Ini berguna apabila anda ingin mengurus aliran data tanpa perlu menyegerakkan setiap Goroutine.
func main() {
messageChannel := make(chan string, 2) // Buffered channel with capacity of 2
messageChannel <- "Message 1"
messageChannel <- "Message 2"
// messageChannel <- "Message 3" // This would block as the buffer is full
fmt.Println(<-messageChannel)
fmt.Println(<-messageChannel)
}
Saluran buffer menambah sedikit lebih fleksibiliti, tetapi penting untuk mengurus saiz penimbal dengan berhati-hati untuk mengelakkan kebuntuan.
Elakkan Menyekat Goroutine: Jika Goroutine menghalang dan tiada cara untuk membebaskannya, anda akan mendapat jalan buntu. Gunakan saluran atau pembatalan konteks untuk mengelakkan perkara ini.
Gunakan pilih dengan Saluran: Apabila bekerja dengan berbilang saluran, pernyataan pilihan membolehkan anda mengendalikan mana-mana saluran yang sedia dahulu, mengelakkan kemungkinan sekatan.
select {
case msg := <-channel1:
fmt.Println("Received from channel1:", msg)
case msg := <-channel2:
fmt.Println("Received from channel2:", msg)
default:
fmt.Println("No data received")
}
close(messageChannel)
Pantau Penggunaan Memori: Memandangkan Goroutines sangat ringan, mudah untuk menghasilkan terlalu banyak. Pantau penggunaan memori aplikasi anda untuk mengelak daripada membebankan sistem.
Gunakan Konteks untuk Pembatalan: Apabila anda perlu membatalkan Goroutines, gunakan pakej konteks Go untuk menyebarkan isyarat pembatalan.
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
go func(ctx context.Context) {
for {
select {
case <-ctx.Done():
return
default:
// Continue processing
}
}
}(ctx)
Groutine ialah ciri yang berkuasa dalam Go, menjadikan pengaturcaraan serentak boleh diakses dan berkesan. Dengan memanfaatkan Goroutines, WaitGroups dan Channels, anda boleh membina aplikasi yang mengendalikan tugas secara serentak, skala dengan cekap dan menggunakan sepenuhnya pemproses berbilang teras moden.
Essayez-le : Expérimentez avec les Goroutines dans vos propres projets ! Une fois que vous les maîtriserez, vous constaterez qu’ils ouvrent un tout nouveau monde de possibilités pour les applications Go. Bon codage ! ?
Quel est votre cas d'utilisation préféré pour les Goroutines ? Faites-le-moi savoir dans les commentaires ou partagez tout autre conseil que vous avez pour utiliser efficacement les Goroutines !
Atas ialah kandungan terperinci Cara Menggunakan Goroutines untuk Pemprosesan Serentak dalam Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
