Bagaimana untuk menggunakan Goroutines dalam Go?

Bahasa Go ialah bahasa pengaturcaraan yang menyokong konkurensi, dan salah satu ciri terasnya ialah Goroutines. Goroutine ialah utas ringan yang membolehkan kami membuat proses pelaksanaan serentak dalam program kami. Dengan menggunakan Goroutines, kita boleh menulis atur cara serentak yang cekap dengan mudah. Dalam artikel ini, kita akan belajar cara menggunakan Goroutines dalam Go.

Apakah itu Goroutines?

Groutine ialah utas ringan yang diuruskan oleh masa jalan Go. Tidak seperti urutan sistem pengendalian, Goroutines tidak diurus oleh kernel sistem pengendalian, tetapi disokong oleh masa jalan Go. Oleh itu, Goroutines lebih ringan, dan mencipta serta memusnahkan Goroutines adalah lebih pantas daripada rangkaian sistem pengendalian. Goroutines ialah teras keselarasan bahasa Go, membolehkan keupayaan untuk memisahkan dan melaksanakan badan fungsi secara serentak.

Cara Goroutine dicipta

Dalam Go, kita boleh menggunakan kata kunci go untuk mencipta Goroutine baharu. Berikut ialah contoh mudah:

package main

import (
    "fmt"
    "time"
)

func hello() {
    fmt.Println("Hello goroutine!")
}

func main() {
    go hello()
    time.Sleep(1 * time.Second)
    fmt.Println("main function")
}

Dalam contoh ini, kami mentakrifkan fungsi hello yang akan dilaksanakan dalam Goroutine baharu. Kami mencipta Goroutine baharu menggunakan kata kunci main dalam fungsi go, menghantar fungsi hello kepadanya sebagai parameter. Apabila kita menjalankan program, fungsi hello akan berjalan secara tidak segerak dalam Goroutine baharu, manakala fungsi main akan terus dilaksanakan. Kami menggunakan fungsi time.Sleep untuk membuat fungsi main menunggu selama 1 saat untuk memastikan fungsi hello mempunyai masa yang mencukupi untuk dilaksanakan.

Proses pelaksanaan Goroutines

Selepas Goroutines dicipta, mereka akan dilaksanakan serentak dengan urutan utama Goroutines boleh melaksanakan fungsi atau kod lain secara tidak segerak dan serentak. Program Go dimulakan dalam Goroutine utama. Apabila kami menggunakan kata kunci go untuk mencipta Goroutine baharu, masa jalan Go akan mencipta utas ringan baharu dan memperuntukkan tindanan Goroutine, dan kemudian menambah Goroutine pada penjadual masa jalan Go. Masa jalanan Go akan memilih Goroutine yang tersedia untuk dijalankan berdasarkan algoritma penjadualan yang tersedia ini, mungkin terdapat Goroutine dalam program Go yang lain. Jika masa jalanan Go tidak menjumpai Goroutine yang tersedia, program mungkin akan tidur.

Penjadualan Goroutines

Masa jalan Go menggunakan penjadual Go untuk menjadualkan perjalanan Goroutines. Apabila kami mencipta Goroutine baharu, ia ditambahkan pada baris gilir larian penjadual. Apabila penjadual bersedia untuk menjalankan Goroutine, ia akan memilih Goroutine daripada baris gilir untuk dijalankan sehingga Goroutine menyekat atau memanggil fungsi seperti time.Sleep. Dalam kes ini, penjadual menjeda pelaksanaan Goroutine dan meletakkannya semula pada baris gilir sehingga ia bersedia untuk dijalankan semula.

Menyekat Goroutines

Menyekat merujuk kepada keadaan di mana Goroutines tidak boleh terus melaksanakan. Apabila Goroutine memanggil beberapa fungsi menyekat, Goroutine akan digantung sehingga fungsi itu mengembalikan hasil. Fungsi ini termasuk: operasi I/O, permintaan rangkaian, panggilan sistem, kunci, dsb. Jika Goroutine disekat, penjadual meletakkan Goroutine semula ke dalam baris gilir sehingga ia bersedia untuk dijalankan semula.

Penyegerakan Goroutines

Dalam Go, kita boleh menggunakan saluran (Saluran) untuk penyegerakan dan komunikasi antara Goroutines. Saluran ialah mekanisme untuk menghantar data antara Goroutines, yang boleh menyekat pelaksanaan Goroutines. Berikut ialah contoh menggunakan saluran untuk penyegerakan:

package main

import (
    "fmt"
)

func main() {
    ch := make(chan int)

    go func() {
        fmt.Println("Goroutine starts")
        ch <- 1
    }()

    fmt.Println("Main goroutine waiting")
    <-ch
    fmt.Println("Main goroutine exiting")
}

Dalam contoh ini, kami mula-mula mencipta saluran ch dan kemudian melaksanakan fungsi dalam Goroutine baharu. Dalam fungsi itu, kami mencetak mesej dan menulis nombor 1 ke saluran. Dalam fungsi main, kami menunggu pada saluran sehingga kami menerima nilai. Sebaik sahaja kami menerima nilai, fungsi main akan keluar. Ini adalah contoh yang sangat mudah, tetapi ia menunjukkan cara menggunakan saluran untuk menyegerakkan antara Goroutines.

Ralat pengendalian Goroutines

Apabila Goroutine menghadapi ralat, ia akan ranap dan menimbulkan ralat Panik. Apabila ralat berlaku dalam Goroutine, mesej ralatnya hanya akan dikeluarkan kepada konsol dan status Goroutine tidak boleh diakses. Untuk mengelakkan ranap program, kami boleh menggunakan fungsi pulih untuk pulih daripada ralat Panic. Berikut ialah contoh menggunakan fungsi pulih:

package main

import (
    "fmt"
)

func main() {
    // define a function to run inside Goroutine
    goroutineFunc := func() {
        defer func() {
            if err := recover(); err != nil {
                fmt.Println("Error:", err)
            }
        }()
        fmt.Println("Goroutine started")
        panic("Something went wrong")
    }

    // start Goroutine
    go goroutineFunc()

    // wait in case Goroutine is not finished yet
    var input string
    fmt.Scanln(&input)
    fmt.Println("End of program")
}

Dalam contoh ini, kita mula-mula mentakrifkan fungsi goroutineFunc, yang akan dilaksanakan dalam Goroutine baharu. Dalam fungsi tersebut, kami mencetak mesej dan memanggil fungsi panic untuk mensimulasikan ralat. Dalam goroutineFunc, kami menggunakan kata kunci defer untuk mentakrifkan fungsi yang digunakan untuk menangkap ralat Panik. Apabila kita melaksanakan fungsi goroutineFunc di dalam panic, fungsi itu ranap dan menimbulkan ralat Panik. Memandangkan kami menggunakan fungsi defer di dalam fungsi recover, kami boleh menangkap ralat ini dan mencetak mesej ralat pada konsol.

Kesimpulan

Gorutin ialah salah satu ciri teras keselarasan bahasa Go Mereka boleh mencipta dan memproses proses pelaksanaan selari dalam program dan meningkatkan prestasi program. Dalam artikel ini, kami mempelajari cara menggunakan Goroutines dalam Go, termasuk cara membuat Goroutines, aliran pelaksanaan Goroutines, penjadualan, penyekatan, penyegerakan dan pengendalian ralat, dsb. Dengan menggunakan Goroutines, kita boleh menulis atur cara serentak yang cekap dengan mudah.

Atas ialah kandungan terperinci Bagaimana untuk menggunakan Goroutines dalam Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!