Laksanakan corak pengaturcaraan tak segerak yang cekap menggunakan bahasa Go

Gunakan bahasa Go untuk melaksanakan model pengaturcaraan tak segerak yang cekap

Dengan perkembangan pesat teknologi Internet, keperluan prestasi dan kebolehskalaan aplikasi moden semakin tinggi dan lebih tinggi. Untuk menangani cabaran ini, pengaturcaraan tak segerak telah menjadi standard dalam bahasa pengaturcaraan moden. Bahasa Go ialah bahasa yang sesuai secara semula jadi untuk pengaturcaraan tak segerak Sintaksnya yang mudah dan mekanisme konkurensi yang cekap telah menjadi pilihan ramai pembangun.

Kelebihan model pengaturcaraan tak segerak ialah ia boleh meningkatkan kelajuan tindak balas dan daya pemprosesan sistem. Tetapi pada masa yang sama, pengaturcaraan tak segerak juga meningkatkan kerumitan kod. Dalam bahasa Go, kita boleh mencapai pengaturcaraan tak segerak yang cekap dengan menggunakan goroutine dan saluran.

1. goroutine

goroutine ialah unit pelaksanaan ringan dalam bahasa Go. Berbanding dengan utas dalam bahasa lain, goroutine lebih ringan dan boleh dibuat dan dimusnahkan dengan lebih cepat Dalam bahasa Go, berjuta-juta gorouti boleh dibuat dengan mudah tanpa banyak overhead.

Cara untuk membuat goroutine adalah sangat mudah, cuma tambah kata kunci go sebelum panggilan fungsi. Contohnya:

func main(){
    go func(){
        //code
    }()
}

2. saluran

saluran ialah mekanisme dalam bahasa Go untuk komunikasi antara goroutine. Saluran boleh merealisasikan komunikasi segerak dan tak segerak, dan menggunakan saluran boleh mengelakkan masalah memori yang dikongsi, jadi ia boleh mengelakkan persaingan data dengan berkesan.

Kaedah penciptaan saluran juga sangat mudah, hanya gunakan fungsi buat.

c := make(chan int)

Operasi penghantaran dan penerimaan saluran menggunakan simbol <-, contohnya:

c <- value // 发送value到channel
v := <-c // 从channel中接收值并赋值给v

Menggunakan saluran boleh mencapai penyegerakan dan komunikasi antara berbilang gorouti. Sebagai contoh, dalam contoh berikut, kita boleh menggunakan saluran untuk menyegerakkan pelaksanaan dua goroutine:

func main() {
    c := make(chan int)
    go func() {
        c <- 1 // send 1 to channel c
    }()
    v := <-c // receive from channel c
    fmt.Println(v) // output: 1
}

3. pilih

Dalam bahasa Pergi, pilih digunakan Perform operasi tanpa sekatan pada berbilang saluran. Sintaks pilih adalah serupa dengan suis, tetapi ungkapan selepas kes mestilah operasi saluran, contohnya:

select {
case v := <-ch1:
    fmt.Println("received from ch1: ", v)
case v := <-ch2:
    fmt.Println("received from ch2: ", v)
}

Jika berbilang kes boleh dilaksanakan, pilih akan memilih salah satu daripadanya secara rawak. Jika tiada kes dalam pilihan yang boleh dilaksanakan, ia akan menyekat sehingga sekurang-kurangnya satu kes boleh dilaksanakan.

Apabila menggunakan pilih, kita boleh menggunakan pernyataan lalai untuk mengendalikan beberapa situasi khas. Contohnya:

select {
case v := <-ch1:
    fmt.Println("received from ch1: ", v)
case v := <-ch2:
    fmt.Println("received from ch2: ", v)
default:
    fmt.Println("no message received")
}

4. Kod contoh

Berikut ialah contoh penggunaan goroutine dan saluran untuk melaksanakan pengaturcaraan tak segerak. Dalam contoh ini, kita akan memulakan berbilang goroutine untuk mengira jujukan Fibonacci Selepas pengiraan selesai, gunakan saluran untuk memindahkan hasil pengiraan ke goroutine utama. Akhirnya, goroutine utama akan mengeluarkan hasil pengiraan ke konsol.

package main

import (
    "fmt"
)

func fibonacci(n int, c chan int) {
    if n < 2 {
        c <- n
        return
    }
    c1 := make(chan int)
    c2 := make(chan int)
    go fibonacci(n-1, c1)
    go fibonacci(n-2, c2)
    x, y := <-c1, <-c2
    c <- x + y
}

func main() {
    n := 10
    c := make(chan int)
    go fibonacci(n, c)
    res := <-c
    fmt.Printf("fibonacci(%d)=%d
", n, res)
}

Dalam contoh di atas, kami menggunakan kaedah rekursif untuk mengira jujukan Fibonacci dan menggunakan dua saluran untuk menyegerakkan pengiraan. Dalam goroutine utama, kita hanya perlu menunggu hasil pengiraan, dan keseluruhan proses adalah sangat mudah dan cekap.

Ringkasan

Bahasa Go menyediakan model pengaturcaraan tak segerak yang cekap, membolehkan pembangun melaksanakan aplikasi berprestasi tinggi dan berskala dengan mudah. Dengan menggunakan goroutine, saluran dan pilih, kami boleh melaksanakan pengaturcaraan tak segerak dengan mudah. Apabila menggunakan bahasa Go untuk pembangunan, adalah disyorkan untuk menggunakan mod pengaturcaraan tak segerak untuk memberikan permainan penuh kepada kelebihan bahasa Go dan menjadikan program lebih cekap dan mantap.

Atas ialah kandungan terperinci Laksanakan corak pengaturcaraan tak segerak yang cekap menggunakan bahasa Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!