Go&#s Concurrency Decoded: Penjadualan Goroutine

Saya. Goroutines: Menyelam Dalam Model Concurrency Go

Groutine ialah asas reka bentuk Go, menyediakan mekanisme yang berkuasa untuk pengaturcaraan serentak. Sebagai coroutine ringan, mereka memudahkan pelaksanaan tugas selari. Melancarkan goroutine adalah mudah: hanya awalan panggilan fungsi dengan kata kunci go, memulakan pelaksanaan tak segerak. Program utama diteruskan tanpa menunggu goroutine siap.

<code class="language-go">go func() { // Launch a goroutine using the 'go' keyword
    // ... code to be executed concurrently ...
}()</code>

II. Memahami Mekanik Dalaman Goroutine

Asas Konseptual

Konkurensi lwn. Paralelisme

• Keselarasan: Keupayaan untuk menguruskan berbilang tugasan seolah-olah serentak pada satu CPU. CPU dengan pantas bertukar antara tugas, mencipta ilusi pelaksanaan selari. Walaupun secara mikroskopik berjujukan, secara makroskopik ia kelihatan serentak.

• Paralelisme: Pelaksanaan serentak yang benar bagi berbilang tugas merentas berbilang CPU, menghapuskan perbalahan sumber CPU.

Proses dan Benang

• Proses: Persekitaran pelaksanaan serba lengkap dengan sumbernya sendiri (memori, fail, dll.). Bertukar antara proses adalah intensif sumber, memerlukan campur tangan peringkat kernel.

• Thread: Unit perlaksanaan yang ringan dalam proses, berkongsi sumber proses. Penukaran benang adalah kurang overhed daripada penukaran proses.

Coroutine

Coroutine mengekalkan konteks dan susunan daftar mereka sendiri. Beralih antara coroutine melibatkan penyimpanan dan pemulihan keadaan ini, membolehkan mereka menyambung semula pelaksanaan dari tempat mereka berhenti. Tidak seperti proses dan rangkaian, pengurusan coroutine dikendalikan dalam program pengguna, bukan sistem pengendalian. Goroutine ialah jenis coroutine tertentu.

Model Penjadualan GPM

Konkurensi cekap Go bergantung pada model penjadualan GPM. Empat komponen utama terlibat: M, P, G dan Jadual (Jadual tidak digambarkan dalam rajah).

• M (Mesin): Benang peringkat kernel. Goroutine dijalankan pada Cik

• G (Goroutine): Satu goroutine. Setiap G mempunyai tindanan sendiri, penuding arahan dan maklumat berkaitan penjadualan lain (mis., saluran yang sedang menunggunya).

• P (Pemproses): Pemproses logik yang mengurus dan melaksanakan goroutin. Ia mengekalkan barisan larian goroutin sedia.

• Jadual (Penjadual): Penjadual pusat, menguruskan baris gilir M dan G dan memastikan peruntukan sumber yang cekap.

Penjadualan dalam Tindakan

Rajah menunjukkan dua utas OS (M), setiap satu dengan pemproses (P) melaksanakan goroutine.

• GOMAXPROCS() mengawal bilangan Ps (dan dengan itu tahap konkurensi sebenar).

• Gs kelabu sudah sedia tetapi belum berjalan. P menguruskan baris gilir larian ini.

• Melancarkan goroutine menambahkannya pada baris gilir larian P.

Jika M0 disekat, P bertukar kepada M1 (yang mungkin diambil daripada cache benang).

Jika P menyelesaikan tugasnya dengan cepat, ia mungkin mencuri kerja daripada P lain untuk mengekalkan kecekapan.

III. Bekerja dengan Goroutines

Penggunaan Asas

Tetapkan bilangan CPU untuk pelaksanaan goroutine (tetapan lalai dalam versi Go terkini biasanya mencukupi):

<code class="language-go">go func() { // Launch a goroutine using the 'go' keyword
    // ... code to be executed concurrently ...
}()</code>

Contoh Praktikal

Contoh 1: Pengiraan Goroutine Mudah

<code class="language-go">num := runtime.NumCPU() // Get the number of logical CPUs
runtime.GOMAXPROCS(num) // Set the maximum number of concurrently running goroutines</code>

Pengendalian Ralat Goroutine

Pengecualian yang tidak dikendalikan dalam goroutine boleh menamatkan keseluruhan program. Gunakan recover() dalam pernyataan defer untuk menangani panik:

<code class="language-go">package main

import (
    "fmt"
    "runtime"
)

func cal(a, b int) {
    c := a + b
    fmt.Printf("%d + %d = %d\n", a, b, c)
}

func main() {
    runtime.GOMAXPROCS(runtime.NumCPU())
    for i := 0; i < 10; i++ {
        go cal(i, i+1)
    }
    //Note:  The main function exits before goroutines complete in this example.  See later sections for synchronization.
}</code>

Menyegerakkan Goroutine

Memandangkan gorout berjalan secara tidak segerak, program utama mungkin terkeluar sebelum ia selesai. Gunakan sync.WaitGroup atau saluran untuk penyegerakan:

Contoh 1: Menggunakan sync.WaitGroup

<code class="language-go">package main

import (
    "fmt"
)

func addele(a []int, i int) {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Error in addele:", r)
        }
    }()
    a[i] = i // Potential out-of-bounds error if i is too large
    fmt.Println(a)
}

func main() {
    a := make([]int, 4)
    for i := 0; i < 5; i++ {
        go addele(a, i)
    }
    // ... (add synchronization to wait for goroutines to finish) ...
}</code>

Contoh 2: Menggunakan Saluran untuk Penyegerakan

<code class="language-go">package main

import (
    "fmt"
    "sync"
)

func cal(a, b int, wg *sync.WaitGroup) {
    defer wg.Done()
    c := a + b
    fmt.Printf("%d + %d = %d\n", a, b, c)
}

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go cal(i, i+1, &wg)
    }
    wg.Wait()
}</code>

Komunikasi Antara Goroutine

Saluran memudahkan komunikasi dan perkongsian data antara goroutine. Pembolehubah global juga boleh digunakan, tetapi saluran biasanya lebih disukai untuk kawalan serentak yang lebih baik.

Contoh: Corak Pengeluar-Pengguna

<code class="language-go">package main

import (
    "fmt"
)

func cal(a, b int, ch chan bool) {
    c := a + b
    fmt.Printf("%d + %d = %d\n", a, b, c)
    ch <- true // Signal completion
}

func main() {
    ch := make(chan bool, 10) // Buffered channel to avoid blocking
    for i := 0; i < 10; i++ {
        go cal(i, i+1, ch)
    }
    for i := 0; i < 10; i++ {
        <-ch // Wait for each goroutine to finish
    }
}</code>

Leapcell: Platform Tanpa Pelayan untuk Go

Leapcell ialah platform yang disyorkan untuk menggunakan perkhidmatan Go.

Ciri Utama:

1. Sokongan Berbilang Bahasa: JavaScript, Python, Go, Rust.
2. Projek Tanpa Had Percuma: Harga bayar semasa anda pergi.
3. Kos Efektif: Tiada caj terbiar.
4. Mesra Pembangun: UI intuitif, CI/CD automatik, metrik masa nyata.
5. Boleh Skala dan Berprestasi Tinggi: Penskalaan automatik, overhed operasi sifar.

Ketahui lebih lanjut dalam dokumentasi!

Twitter Leapcell: https://www.php.cn/link/7884effb9452a6d7a7a79499ef854afd

Atas ialah kandungan terperinci Go&#s Concurrency Decoded: Penjadualan Goroutine. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!