kaedah golang async

Pengaturcaraan tak segerak ialah teknik yang sangat popular dalam bahasa pengaturcaraan moden. Dalam golang, kaedah tak segerak boleh meningkatkan prestasi aplikasi, terutamanya dalam aplikasi rangkaian trafik tinggi. Dalam artikel ini, kami akan memperkenalkan kaedah async dalam golang dan penggunaannya.

Golang ialah bahasa pengaturcaraan yang cekap yang sangat sesuai untuk digunakan dalam aplikasi konkurensi tinggi. Ia menyediakan beberapa alatan terbina dalam untuk memudahkan pengaturcaraan tak segerak.

Dalam model pengaturcaraan segerak tradisional, tugasan akan dilaksanakan mengikut turutan. Iaitu, setiap tugasan mesti menunggu tugasan sebelumnya selesai sebelum ia boleh memulakan pelaksanaan. Pendekatan ini bergantung pada pengkomputeran bersiri Walaupun ia boleh mengawal konkurensi dengan berkesan, dalam senario aplikasi trafik tinggi, model pengaturcaraan segerak akan menjadi tidak mencukupi.

Sebaliknya, model pengaturcaraan tak segerak menggunakan mekanisme gelung peristiwa untuk membenarkan aplikasi mengendalikan berbilang tugas secara serentak dalam satu utas. Model pengaturcaraan tak segerak berprestasi lebih baik dalam aplikasi trafik tinggi kerana ia membolehkan anda mengendalikan berbilang tugas secara serentak tanpa menyekat, dan aplikasi tidak dikunci pada tugasan yang berjalan lama.

Di golang, teras pengaturcaraan tak segerak ialah goroutine. Goroutines membolehkan anda melancarkan benang ringan dalam aplikasi anda, dan ia boleh dijalankan serentak dengan goroutin lain. Ini menjadikannya sangat mudah untuk menggunakan pengaturcaraan tak segerak dalam golang.

Sintaks asas untuk mencipta kaedah tak segerak menggunakan goroutine adalah seperti berikut:

go methodName()

Dalam sintaks ini, kata kunci "go" memberitahu pengurus golang untuk melancarkan kaedah sebagai goroutine dan bukannya menyekat aplikasi menunggu Kaedah berakhir.

Jika anda ingin menggunakan parameter dalam kaedah tak segerak, anda perlu menghantar parameter kepada kaedah tersebut. Anda boleh menggunakan kata kunci "pergi" dan hantar parameter kepada kaedah seperti ini:

go methodName(argument1, argument2)

Berikut ialah contoh mudah yang menunjukkan cara mencipta kaedah async dan menghantar parameter kepadanya:

package main

import (
    "fmt"
    "time"
)

func main() {
    go printMessage("Hello", "World")
    fmt.Scanln()
    fmt.Println("Program Exit")
}

func printMessage(message string, name string) {
    time.Sleep(2 * time.Second)
    fmt.Printf("%s %s!
", message, name)
}

Dalam contoh ini, kami menulis kaedah yang dipanggil "printMessage" yang menerima dua parameter dan mencetak parameter ini ke konsol selepas 2 saat. Kami melancarkan kaedah ini sebagai goroutine dengan menggunakan kata kunci "pergi".

Dalam fungsi utama, kami menggunakan kaedah fmt.Scanln() untuk menjeda aplikasi untuk menunggu kaedah async selesai. Ini membolehkan kami memastikan aplikasi aktif sehingga program menyelesaikan semua kerjanya. Akhir sekali, kami mencetak mesej yang menunjukkan bahawa program telah keluar.

Apabila anda menjalankan aplikasi ini, anda akan melihatnya dengan serta-merta mengeluarkan mesej "Keluar Program" dan berhenti berjalan. Ini kerana utas utama keluar tanpa menunggu kaedah tak segerak yang mencetak mesej selesai.

Contoh ini mungkin mudah, tetapi ia menunjukkan asas kaedah tak segerak dan goroutin. Ia menjadi lebih berguna apabila anda menggunakan pengaturcaraan tak segerak dalam aplikasi yang lebih kompleks.

Selain menggunakan goroutine, golang juga menyediakan beberapa alat lain untuk memudahkan pengaturcaraan tak segerak. Sebagai contoh, golang menyediakan jenis khas yang dipanggil "Saluran" dalam perpustakaan standard yang boleh digunakan untuk memindahkan data antara goroutine.

Saluran boleh membantu anda mengurus keadaan biasa dalam aplikasi anda dan menghalang isu perlumbaan data antara berbilang goroutine menulis dan membaca secara serentak. Mari lihat contoh yang menunjukkan cara menggunakan Saluran untuk memindahkan data antara goroutine.

package main

import (
    "fmt"
)

func main() {
    channel := make(chan string)
    go sendName("John", channel)
    fmt.Println(<-channel)
}

func sendName(name string, ch chan string) {
    ch <- name
}

Dalam contoh ini, kami mencipta Saluran bernama "saluran" dan menghantarnya kepada kaedah "sendName". Kaedah ini menulis nama "John" ke saluran dengan menggunakan operator "<-". Dalam fungsi utama, kami menunggu kaedah sendName untuk membaca nama ke dalam saluran dan mencetaknya ke konsol.

Apabila anda menjalankan aplikasi ini, anda akan melihatnya mencetak "John". Cuba kod ini bersama-sama dengan contoh penggunaan goroutine dalam aplikasi yang sama untuk melihat cara menggunakan model pengaturcaraan tak segerak dengan Saluran.

Dalam artikel ini, kami memperkenalkan pengaturcaraan tak segerak dan goroutin dalam golang. Kaedah tak segerak menyediakan cara untuk mengendalikan berbilang tugas secara serentak, yang boleh meningkatkan prestasi aplikasi ke tahap yang lebih tinggi. Dalam golang, sangat mudah untuk mencipta kaedah tak segerak menggunakan goroutine, dan pengaturcaraan tak segerak yang lebih maju boleh dilakukan menggunakan alat lain seperti Saluran.

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