Apakah maksud golang asynchronous?

golang async merujuk kepada gaya pengaturcaraan yang membolehkan aplikasi melaksanakan berbilang tugas tanpa menunggu setiap tugas selesai. Kaedah untuk mencapai pelaksanaan tak segerak: 1. Goroutine, dengan menggunakan kata kunci pergi, anda boleh membuat berbilang goroutine dalam program, dan goroutine ini boleh melaksanakan tugas yang berbeza secara serentak 2. Saluran, dengan menggunakan saluran, anda boleh menghantar antara data goroutine yang berbeza memastikan bahawa ia dilaksanakan dalam penyelarasan apabila diperlukan 3. Gunakan fungsi panggil balik untuk melaksanakan operasi tak segerak.

Persekitaran pengendalian artikel ini: sistem Windows 10, versi go1.20, komputer dell g3.

Dalam dunia pengaturcaraan, tak segerak ialah konsep yang sangat penting. Ia merujuk kepada gaya pengaturcaraan yang membolehkan aplikasi melakukan pelbagai tugas tanpa menunggu setiap tugas selesai. Sebaliknya, ia membenarkan program untuk terus melaksanakan operasi lain semasa melaksanakan tugas, dengan itu meningkatkan kecekapan dan responsif.

Golang (juga dikenali sebagai bahasa Go) ialah bahasa pengaturcaraan sistem moden yang menyokong operasi tak segerak secara asli. Ia sangat baik dalam mengoptimumkan prestasi kod dan mengendalikan konkurensi. Di Golang, terdapat banyak cara untuk melaksanakan kaedah tak segerak, dan kami akan memperkenalkannya satu demi satu dalam artikel ini.

1. Goroutine

Kaedah tak segerak yang paling biasa digunakan di Golang ialah menggunakan goroutine. Goroutine ialah benang ringan yang diuruskan oleh pengkompil Go. Dengan menggunakan kata kunci go, kami boleh mencipta berbilang gorouti dalam program dan gorouti ini boleh melaksanakan tugas yang berbeza secara serentak.

Berikut ialah contoh yang menunjukkan cara melaksanakan operasi tak segerak menggunakan goroutine:

func main() {
    go calculateSum(10, 20)
    // 执行其他任务
}
func calculateSum(a, b int) {
    sum := a + b
    fmt.Println("Sum:", sum)
}

Dalam contoh di atas, kami melaksanakan fungsi calculateSum secara serentak tanpa menunggu selesai. Ini membolehkan utas utama melaksanakan tugas lain secara serentak.

Perlu dinyatakan bahawa pada akhir goroutine utama (iaitu fungsi utama), semua goroutine lain akan ditamatkan secara automatik. Jika kita mahu menunggu goroutine untuk menyelesaikan pelaksanaan, kita boleh menggunakan WaitGroup dalam pakej penyegerakan.

2. Saluran

Saluran Golang ialah satu lagi alat pengaturcaraan tak segerak yang berkuasa. Saluran membenarkan komunikasi dan penyegerakan antara gorouti yang berbeza. Dengan menggunakan saluran, kami boleh menghantar data antara gorouti yang berbeza dan memastikan ia dilaksanakan dalam penyelarasan apabila diperlukan.

Berikut ialah contoh yang menunjukkan cara melaksanakan operasi tak segerak menggunakan saluran:

func main() {
    c := make(chan int)
    go calculateSum(10, 20, c)
    // 执行其他任务
    sum := <-c
    fmt.Println("Sum:", sum)
}
func calculateSum(a, b int, c chan int) {
    sum := a + b
    c <- sum
}

Dalam contoh di atas, kami mencipta saluran c yang tidak ditimbal dan menghantarnya kepada fungsi calculateSum. Dalam fungsi calculateSum, kami menghantar hasil pengiraan ke saluran melalui c <- sum.

Urut utama menerima data daripada saluran melalui <-c dan mencetaknya. Jika tiada goroutine menghantar data ke saluran sebelum menerima data, utas utama akan menyekat dan menunggu.

Perlu diingatkan bahawa saluran juga boleh mempunyai penimbal. Ini bermakna kita boleh menyimpan beberapa data dalam saluran sebelum menghantarnya, sekali gus mengelak daripada menyekat menunggu.

3. Fungsi panggil balik

Selain goroutine dan saluran, kami juga boleh menggunakan fungsi panggil balik untuk melaksanakan operasi tak segerak. Dalam corak fungsi panggil balik, kami menghantar fungsi sebagai parameter kepada fungsi lain dan memanggil fungsi ini pada masa yang sesuai.

Berikut ialah contoh yang menunjukkan cara melaksanakan operasi tak segerak menggunakan fungsi panggil balik:

func main() {
    calculateSum(10, 20, func(sum int) {
        fmt.Println("Sum:", sum)
    })
    // 执行其他任务
}
func calculateSum(a, b int, callback func(int)) {
    sum := a + b
    callback(sum)
}

Dalam contoh di atas, kami menghantar fungsi tanpa nama kepada fungsi calculateSum, yang dipanggil selepas pengiraan selesai. Dengan cara ini kita boleh melakukan operasi lain selepas pengiraan selesai tanpa menunggu pengiraan selesai.

Ringkasan:

Di atas memperkenalkan tiga kaedah biasa untuk melaksanakan operasi tak segerak di Golang: goroutine, saluran dan fungsi panggil balik. Goroutine dan saluran ialah mekanisme berkuasa yang disokong asli oleh Golang dan boleh membantu kami mengendalikan konkurensi dengan lebih baik. Fungsi panggil balik ialah corak biasa dan sesuai untuk situasi tertentu.

Dalam pengaturcaraan tak segerak, kita boleh memilih kaedah yang sesuai berdasarkan ciri dan keperluan tugas. Kaedah tak segerak ini menjadikan Golang sebagai bahasa pengaturcaraan yang sangat sesuai untuk pemprosesan berprestasi tinggi dan serentak. Sama ada mengendalikan permintaan rangkaian, pertanyaan pangkalan data atau jenis tugas lain, pengaturcaraan tak segerak adalah kunci untuk meningkatkan prestasi aplikasi dan responsif.

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