Alat pengaturcaraan asynchronous Golang: Pemahaman mendalam tentang cara Goroutines berfungsi

Alat pengaturcaraan asynchronous Golang: Pemahaman mendalam tentang prinsip kerja Goroutines

Pengenalan:
Dalam era Internet konkurensi tinggi hari ini, pengaturcaraan tak segerak telah menjadi cara teknikal yang sangat diperlukan. Sebagai bahasa yang direka untuk konkurensi tinggi dan kebolehskalaan tinggi, bahasa Go didatangkan dengan model konkurensi yang berkuasa, iaitu Goroutines. Artikel ini akan melihat secara mendalam cara Goroutines berfungsi dan menggambarkan keupayaan pengaturcaraan tak segerak mereka yang berkuasa dengan beberapa contoh kod.

1. Apakah Goroutines ialah utas ringan dalam bahasa Go Mereka boleh dianggap sebagai kaedah pelaksanaan serentak. Goroutine boleh dibuat dalam program melalui kata kunci terbina dalam
bahasa Go. Apabila anda membuat Goroutines, bahasa Go mengurus penjadualan dan mengurus pelaksanaannya secara automatik. go

2. Cara Goroutines berfungsi

Goroutines mencapai pelaksanaan serentak melalui kaedah yang dipanggil penjadualan koperasi (Penjadualan Koperasi). Dalam model benang tradisional, masa pelaksanaan benang dijadualkan oleh sistem pengendalian. Dalam Goroutines, masa jalan bahasa Go bertanggungjawab untuk menjadualkan pelaksanaan Goroutines.

Apabila Goroutine dicipta, ia akan diletakkan dalam penjadual Goroutine (Goroutine Scheduler) menunggu untuk dijadualkan untuk pelaksanaan. Apabila Goroutine dijadualkan untuk pelaksanaan, masa jalan bahasa Go akan memperuntukkan urutan untuk melaksanakan Goroutine. Jika Goroutine ini menghadapi sekatan semasa pelaksanaan (contohnya, menunggu IO selesai), bahasa Go akan mengitar semula utas yang sedang melaksanakan Goroutine ini dan kemudian menggunakan utas terbiar lain untuk melaksanakan Goroutine lain. Apabila sekatan dilepaskan, Goroutine akan dimasukkan semula ke dalam penjadual untuk menunggu pelaksanaan penjadualan. Kaedah penjadualan kolaboratif ini boleh menggunakan sepenuhnya sumber pengkomputeran dan mengelakkan overhed penukaran yang kerap antara berbilang benang.

3. Contoh penjelasan

Yang berikut menggunakan beberapa contoh untuk menggambarkan keupayaan pengaturcaraan tak segerak yang kuat bagi Goroutines.

Laksanakan berbilang tugas serentak

1. package main
   
   import (
       "fmt"
       "time"
   )
   
   func doTask(id int) {
       time.Sleep(time.Second) // 模拟执行耗时任务
       fmt.Println("Task", id, "done")
   }
   
   func main() {
       for i := 0; i < 10; i++ {
           go doTask(i) // 创建一个Goroutine并调度执行任务
       }
   
       time.Sleep(5 * time.Second) // 等待5秒，确保所有任务都执行完毕
       fmt.Println("All tasks done")
   }

Menjalankan kod di atas akan mengeluarkan hasil yang serupa dengan yang berikut:

Task 0 done
Task 1 done
Task 2 done
Task 3 done
Task 4 done
Task 5 done
Task 6 done
Task 7 done
Task 8 done
Task 9 done
All tasks done

Seperti yang anda lihat, 10 tugasan itu dilaksanakan serentak dan bukannya secara berurutan.

Gunakan saluran untuk komunikasi antara Goroutines

2. package main
   
   import "fmt"
   
   func sendMsg(ch chan string, msg string) {
       ch <- msg // 向通道发送消息
   }
   
   func main() {
       ch := make(chan string) // 创建一个字符串通道
   
       go sendMsg(ch, "Hello")
       go sendMsg(ch, "World")
   
       msg1 := <-ch // 从通道接收消息
       msg2 := <-ch
   
       fmt.Println(msg1, msg2) // 输出 "Hello World"
   }

Contoh di atas menunjukkan pemindahan data antara Goroutines melalui saluran. Dengan menggunakan saluran, kami boleh mencapai kerjasama dan komunikasi antara berbilang Goroutine yang melaksanakan secara serentak.

Kesimpulan:

Dengan pemahaman yang mendalam tentang cara Goroutines berfungsi, kami dapat merealisasikan potensi penuh pengaturcaraan tak segerak di Golang. Dengan menggunakan Goroutines secara rasional, kami boleh menggunakan sumber pengkomputeran dengan lebih baik dan meningkatkan prestasi konkurensi sistem. Pada masa yang sama, Goroutines menyediakan model pengaturcaraan serentak yang berkuasa Dengan berkomunikasi antara Goroutines melalui saluran, kami boleh membina program pengaturcaraan tak segerak yang lebih mantap dan cekap.

Atas ialah kandungan terperinci Alat pengaturcaraan asynchronous Golang: Pemahaman mendalam tentang cara Goroutines berfungsi. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!