Bagaimana untuk melaksanakan pengaturcaraan tak segerak dalam bahasa Go

Dengan perkembangan teknologi Internet yang berterusan, permintaan untuk kesesuaian yang tinggi dan ketersediaan yang tinggi menjadi lebih kuat dan kukuh. Pengaturcaraan asynchronous adalah salah satu cara yang berkesan untuk meningkatkan kecekapan dan responsif berjalan program. Sebagai bahasa pengaturcaraan yang baru muncul, bahasa Go sememangnya menyokong pengaturcaraan serentak dan tak segerak, yang sangat memudahkan kerja pembangunan pengaturcara. Artikel ini akan memperkenalkan cara melaksanakan pengaturcaraan tak segerak dalam bahasa Go.

1. Goroutine dalam bahasa Go

Bahasa Go menyediakan mekanisme goroutine, yang boleh melaksanakan operasi serentak dan tak segerak dengan mudah. Goroutine ialah benang ringan Berbanding dengan benang tradisional, goroutine adalah "lebih murah" dan boleh memulakan atau memusnahkan beribu-ribu benang dalam sekelip mata. Penciptaan, pemusnahan dan penjadualan benang ringan ini dilengkapkan secara automatik mengikut masa jalan bahasa Go tanpa campur tangan manual.

Kod contoh:

func main() {
    go func() {
        fmt.Println("Hello, goroutine!")
    }()
    fmt.Println("main function")
    time.Sleep(time.Second)
}

Dalam kod di atas, goroutine dibuka melalui kata kunci go dan Rentetan "Hello, goroutine!" Dalam fungsi utama, "fungsi utama" String juga dikeluarkan. Jika masa.Fungsi tidur tidak digunakan, atur cara akan keluar serta-merta, dan hasil output hanya akan menjadi "fungsi utama" jika masa.Tidur digunakan, atur cara akan menunggu selama 1 saat, dan hasil output akan termasuk "; Hello, goroutine!".

2. Saluran dalam bahasa Go

goroutine ialah asas untuk pengaturcaraan tak segerak dalam bahasa Go, dan saluran ialah jambatan untuk komunikasi antara goroutine. Saluran ialah mekanisme yang digunakan untuk berkomunikasi antara goroutine. Melalui saluran, pertukaran data dan kerjasama antara gorouti yang berbeza boleh dicapai.

Saluran dalam bahasa Go dibahagikan kepada dua jenis: saluran dengan cache dan saluran tanpa cache. Saluran dengan cache mempunyai kapasiti tertentu dan boleh menyimpan sejumlah elemen tertentu Saluran tanpa cache perlu menunggu pengirim dan penerima bersedia sebelum pertukaran data boleh berlaku.

Kod contoh:

// 带缓存的channel
func main() {
    c := make(chan int, 3)
    c <- 1
    c <- 2
    c <- 3
    fmt.Println(<-c)
    fmt.Println(<-c)
    fmt.Println(<-c)
}

// 不带缓存的channel
func main() {
    c := make(chan int)
    go func() {
        c <- 1
        c <- 2
        c <- 3
    }()
    fmt.Println(<-c)
    fmt.Println(<-c)
    fmt.Println(<-c)
}

Dalam saluran dengan cache, saluran dengan kapasiti penimbal 3 dicipta melalui fungsi make, dan 1, 2, dan 3 dihantar ke saluran dalam nombor urutan, dan baca data melalui <-c. Dalam saluran tanpa caching, tiga nombor 1, 2, dan 3 dihantar ke saluran melalui goroutine, dan data dibaca melalui <-c.

3. Pernyataan pilih dalam bahasa Go

Pernyataan pilih ialah salah satu pernyataan penting dalam bahasa Go untuk melaksanakan pengaturcaraan tak segerak. Ia boleh memilih antara berbilang saluran untuk mencapai menunggu dan penerimaan tak segerak. Manipulasi data. Apabila berbilang saluran sedia, pernyataan pilih secara rawak memilih saluran yang tersedia untuk melaksanakan operasi. Jika tiada saluran tersedia, penyataan pilih akan tidur sehingga saluran sedia.

Kod sampel:

// select语句
func main() {
    c1 := make(chan int)
    c2 := make(chan int)
    go func() {
        time.Sleep(time.Second)
        c1 <- 1
    }()
    go func() {
        time.Sleep(time.Second)
        c2 <- 2
    }()
    select {
    case n := <-c1:
        fmt.Println(n)
    case n := <-c2:
        fmt.Println(n)
    }
}

Dalam kod di atas, data dihantar ke dua saluran berbeza melalui dua goroutine dan data menunggu melalui penyataan pilih. Memandangkan ia tidur selama 1 saat, penyataan pilih akan menunggu selama 1 saat untuk data satu pihak bersedia.

4. async/wait dalam bahasa Go

Sintaks async/wait dalam bahasa Go tidak mempunyai kata kunci bebas seperti bahasa pengaturcaraan lain. Tetapi model pengaturcaraan tak segerak yang serupa boleh dilaksanakan dengan menggunakan goroutine dan penyataan pilih. Contohnya, dalam kod berikut, async dan await digunakan untuk mensimulasikan model pengaturcaraan tak segerak.

Kod sampel:

// 异步编程模型
func main() {
    task := func() (int, error) {
        return 1, nil
    }
    async := func() chan int {
        c := make(chan int)
        go func() {
            n, err := task()
            if err != nil {
                panic(err)
            }
            c <- n
        }()
        return c
    }
    await := func(c chan int) int {
        return <-c
    }
    fmt.Println(await(async()))
}

Dalam kod sampel ini, fungsi yang perlu dipanggil secara tak segerak disimulasikan melalui fungsi tugas. Asynchronousize fungsi ini melalui fungsi async dan kembalikan saluran. Akhir sekali, gunakan fungsi tunggu untuk menunggu keputusan dalam saluran dan kembali. Walaupun kod itu nampaknya telah menambah banyak rangka kerja tambahan, ia masih mensimulasikan model pengaturcaraan tak segerak dengan baik.

Ringkasan

Sebagai bahasa pengaturcaraan yang baru muncul, bahasa Go sememangnya menyokong pengaturcaraan serentak dan tak segerak, yang sangat memudahkan kerja pembangunan pengaturcara. Pengaturcaraan tak segerak yang cekap boleh dilaksanakan dengan mudah dengan menggunakan goroutin, saluran, penyataan pilih dan model tak segerak/menunggu. Pada masa hadapan, kami boleh menjangkakan bahasa Go akan menyokong pengaturcaraan tak segerak dengan lebih baik untuk memenuhi keperluan senario aplikasi berkonkurensi tinggi dan ketersediaan tinggi dengan lebih baik.

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan pengaturcaraan tak segerak dalam bahasa Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!