Goroutine Go melaksanakan serentak, membolehkan fungsi dilaksanakan serentak, berkomunikasi melalui saluran dan menyediakan kawalan ke atas serentak. Penggunaan goroutine boleh meningkatkan prestasi program, terutamanya untuk memproses tugas menyekat. Kod sampel menunjukkan pelaksanaan selari, komunikasi saluran dan kawalan serentak goroutin.
Impak proses Go pada aliran pelaksanaan fungsi Go
Dalam bahasa Go, goroutine ialah utas ringan yang melaksanakan blok kod secara serentak. Tidak seperti benang tradisional, goroutin ialah coroutine, yang bermaksud mereka tidak menduduki benang kernel mereka sendiri, tetapi berkongsi kumpulan benang yang sama dengan goroutines lain. Ciri ini menjadikan Goroutine ringan, cekap dan sangat sesuai untuk mengendalikan tugas serentak.
Aliran pelaksanaan fungsi Go dipengaruhi oleh goroutine dalam aspek berikut:
1. Pelaksanaan selari
goroutine membolehkan fungsi dilaksanakan secara serentak. Dengan mencipta goroutine, anda boleh menjalankan berbilang fungsi secara serentak tanpa menunggu fungsi lain selesai. Ini sangat meningkatkan prestasi program, terutamanya apabila menangani tugas menyekat seperti operasi I/O.
Contoh kod:
package main import ( "fmt" "time" ) func main() { go func() { time.Sleep(1 * time.Second) fmt.Println("Goroutine says hello!") }() fmt.Println("Main function says hi!") }
Output:
Main function says hi! Goroutine says hello!
Dalam kod ini, kami mencipta goroutine dan mencetak "Goroutine mengucapkan hello!" Pada masa yang sama, fungsi utama mencetak "Fungsi utama berkata hi!" Memandangkan goroutine dilaksanakan secara serentak, kedua-dua mesej ini akan dicetak pada masa yang sama.
2. Komunikasi saluran
Komunikasi antara goroutine dilaksanakan melalui saluran. Saluran ialah mekanisme komunikasi jenis selamat yang membolehkan gorout menghantar dan menerima nilai. Ini membolehkan anda menyelaraskan tugas antara goroutine dan mengawal aliran data.
Contoh kod:
package main import ( "fmt" "sync" "time" ) func main() { var wg sync.WaitGroup ch := make(chan int) go func() { for i := 0; i < 10; i++ { ch <- i } wg.Done() }() go func() { for i := 0; i < 10; i++ { fmt.Println(<-ch) } wg.Done() }() wg.Add(2) wg.Wait() }
Output:
0 1 2 3 4 5 6 7 8 9
Kod ini menghasilkan dua goroutine. Goroutine pertama menghantar integer dari 0 hingga 9 ke saluran dan goroutine kedua menerima integer dari saluran dan mencetaknya. waitGroup digunakan untuk memastikan kedua-dua goroutine selesai sebelum keluar dari fungsi utama.
3. Kawal konkurensi
goroutine menambah kawalan ke atas konkurensi. Anda boleh membuat seberapa banyak goroutine yang anda mahu, tetapi penting untuk mengurusnya dengan baik untuk mengelakkan penggunaan sumber yang berlebihan. Bahasa Go mempunyai ciri terbina dalam untuk membantu anda mengawal konkurensi, seperti pakej konteks dan penyegerakan.
Contoh kod:
package main import ( "context" "fmt" "sync" "time" ) func main() { ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() var mu sync.Mutex total := 0 for i := 0; i < 10000; i++ { go func(i int) { mu.Lock() defer mu.Unlock() total += i }(i) } <-ctx.Done() fmt.Println("Total:", total) }
Output:
Total: 49995000
Kod ini mencipta 10000 goroutine, setiap goroutine menambah nilainya sendiri kepada pembolehubah kongsi "jumlah". konteks digunakan untuk mengehadkan masa pelaksanaan goroutine, dan penyegerakan.Mutex digunakan untuk menyegerakkan akses kepada pembolehubah "jumlah". Dengan mengawal konkurensi, kami boleh memastikan ketekalan data.
Memahami kesan goroutine pada aliran pelaksanaan fungsi Go, anda boleh memanfaatkannya untuk menulis program serentak yang cekap dan berskala.
Atas ialah kandungan terperinci Apakah kesan goroutine terhadap aliran pelaksanaan fungsi golang?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!