Kaedah pelaksanaan segerak dan tak segerak bagi fungsi Golang

Golang ialah bahasa pengaturcaraan peringkat tinggi yang menyokong pengaturcaraan serentak Ia menyediakan mekanisme pengaturcaraan serentak yang kaya dan ciri sintaks untuk memudahkan pembangun melaksanakan program berbilang benang atau berbilang coroutine. Antaranya, penyegerakan dan tak segerak ialah dua kaedah yang biasa digunakan dalam pengaturcaraan serentak Artikel ini akan memperkenalkan kaedah pelaksanaan segerak dan tak segerak bagi fungsi Golang dan senario penggunaannya.

1. Kaedah pelaksanaan fungsi segerak

Fungsi segerak bermaksud semasa pelaksanaan fungsi, atur cara akan menunggu fungsi untuk mengembalikan hasil sebelum meneruskan operasi seterusnya. Di Golang, kaedah pelaksanaan fungsi penyegerakan yang biasa digunakan adalah seperti berikut.

1. Menyekat panggilan

Panggilan menyekat ialah kaedah yang paling biasa digunakan untuk melaksanakan fungsi segerak iaitu, apabila fungsi dipanggil, atur cara akan menyekat sehingga fungsi selesai melaksanakan dan mengembalikannya keputusan sebelum meneruskan langkah seterusnya. Contohnya, fungsi f dalam kod berikut ialah panggilan menyekat:

func f() int {
    time.Sleep(time.Second * 5)
    return 42
}

func main() {
    x := f()
    fmt.Println(x)
}

Fungsi f dalam kod di atas menyerupai operasi yang memakan masa dan mengambil masa 5 saat untuk mengembalikan hasilnya. Apabila fungsi f dipanggil dalam fungsi utama, program akan sentiasa menyekat dan menunggu fungsi f menyelesaikan pelaksanaan dan mengembalikan hasilnya sebelum meneruskan ke langkah seterusnya.

2. Penyegerakan berbilang benang

Golang menyediakan mekanisme pengaturcaraan berbilang benang yang boleh menggunakan berbilang benang untuk melaksanakan tugas secara selari. Apabila berbilang benang mengakses sumber yang sama pada masa yang sama, operasi penyegerakan diperlukan untuk mengelakkan keadaan perlumbaan. Kaedah penyegerakan biasa termasuk kunci mutex, pembolehubah keadaan, operasi atom, dsb. Berikut ialah kod sampel yang menggunakan kunci mutex untuk mencapai penyegerakan berbilang benang:

var count int
var mut sync.Mutex

func increment() {
    mut.Lock()
    count++
    mut.Unlock()
}

func main() {
    for i := 0; i < 1000; i++ {
        go increment()
    }
    time.Sleep(time.Second)
    fmt.Println(count)
}

Dalam kod di atas, fungsi kenaikan ialah fungsi yang melakukan operasi kenaikan Melalui kunci mutex, berbilang benang menyedari pembolehubah kiraan Segerakkan operasi untuk mengelakkan keadaan perlumbaan. Program ini melaksanakan fungsi kenaikan 1000 kali secara selari melalui berbilang benang, dan akhirnya mengeluarkan nilai kiraan.

2. Kaedah pelaksanaan fungsi tak segerak

Fungsi tak segerak bermaksud bahawa semasa pelaksanaan fungsi, atur cara tidak menunggu fungsi untuk mengembalikan hasil, tetapi terus melaksanakan yang seterusnya operasi. Apabila fungsi tersebut dilaksanakan, hasilnya akan dihantar kepada program melalui fungsi panggil balik atau pemberitahuan mesej. Di Golang, kaedah pelaksanaan fungsi tak segerak yang biasa digunakan adalah seperti berikut.

1. Coroutine

Coroutine ialah utas ringan di Golang yang boleh melaksanakan berbilang coroutine secara serentak dalam satu utas. Coroutine sangat mudah digunakan dan boleh dimulakan melalui kata kunci pergi.

Berikut ialah contoh kod untuk menggunakan coroutine untuk melaksanakan fungsi tak segerak:

func f() int {
    time.Sleep(time.Second * 5)
    return 42
}

func main() {
    ch := make(chan int)
    go func() {
        ch <- f()
    }()
    fmt.Println("doing other things")
    x := <-ch
    fmt.Println(x)
}

Dalam kod di atas, saluran ch digunakan untuk melaksanakan operasi tak segerak. Mulakan coroutine dalam fungsi utama dan hantar hasil pelaksanaan fungsi f ke program utama melalui saluran ch. Selepas operasi lain dilakukan dalam program utama, hasil pelaksanaan fungsi f diterima melalui saluran untuk menyelesaikan operasi tak segerak.

2. Fungsi panggil balik

Fungsi panggil balik merujuk kepada menghantar hasil kepada program dengan memanggil fungsi panggil balik yang dipradaftarkan selepas fungsi tak segerak dilaksanakan. Berikut ialah contoh kod yang menggunakan fungsi panggil balik untuk melaksanakan fungsi tak segerak:

func f(callback func(int)) {
    time.Sleep(time.Second * 5)
    callback(42)
}

func main() {
    f(func(x int) {
        fmt.Println(x)
    })
    fmt.Println("doing other things")
}

Dalam kod di atas, fungsi f menggunakan fungsi panggil balik untuk melaksanakan operasi tak segerak. Dengan memanggil fungsi panggil balik pradaftar, hasil pelaksanaan fungsi f dihantar ke program. Selepas operasi lain dilakukan dalam program utama, hasil pelaksanaan fungsi f adalah output.

3. Senario penggunaan segerak dan tak segerak

Fungsi segerak dan tak segerak masing-masing mempunyai kelebihan dan kekurangannya sendiri, dan harus dipilih mengikut keperluan perniagaan tertentu.

Apabila anda hanya perlu mendapatkan hasil pelaksanaan fungsi tertentu, seperti operasi permintaan http, dsb., fungsi segerak sering digunakan. Jika anda perlu melakukan operasi yang memakan masa atau perlu mengendalikan berbilang tugas pada masa yang sama, fungsi tak segerak adalah lebih sesuai. Sebagai contoh, apabila memuat turun fail besar, anda boleh menggunakan fungsi tak segerak untuk melaksanakan muat turun serentak dan meningkatkan kelajuan muat turun apabila memproses permintaan rangkaian, anda boleh menggunakan fungsi tak segerak untuk memproses permintaan dan mengurangkan masa menunggu;

Ringkasnya, fungsi segerak dan tak segerak mempunyai kesan penggunaan yang lebih baik dalam senario yang berbeza, dan kita perlu memilih mengikut situasi sebenar.

Atas ialah kandungan terperinci Kaedah pelaksanaan segerak dan tak segerak bagi fungsi Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!