Pergi mengendalikan kesesuaian melalui goroutin dan saluran, membolehkan pengaturcaraan serentak yang mudah, selamat, dan berskala. 1. Goroutine adalah benang ringan yang diuruskan oleh runtime Go, bermula dengan kata kunci Go, dan memerlukan sumber yang minimum kerana susunan kecil dan tumbuh. 2. Saluran memudahkan komunikasi antara goroutin, mencegah keadaan kaum dengan mempromosikan mesej yang melepasi memori bersama, dengan saluran yang tidak dapat diselaraskan menyegerakkan dan menerima, dan saluran buffer yang membolehkan komunikasi tak segerak terhad. 3. Pernyataan SELECT membolehkan multiplexing merentasi pelbagai operasi saluran, menyokong reka bentuk yang tidak menyekat dan responsif. 4. Corak dunia sebenar seperti kolam pekerja menggunakan saluran untuk mengedarkan dan mengumpul tugas dengan cekap merentasi goroutine serentak. 5. Penjadual GO menggunakan model M: N untuk memetakan goroutine ke benang OS, menggunakan pencuri kerja dan preemption untuk mengimbangi beban dan keadilan, berjalan secara lalai pada teras CPU GomaxProcs. Bersama -sama, ciri -ciri ini membolehkan pergi untuk memudahkan pengaturcaraan serentak sambil memastikan kecekapan dan penyelenggaraan.

Pergi mengendalikan kesesuaian melalui goroutin dan saluran , menjadikannya mudah dan cekap untuk menulis program serentak.

Goroutine: Benang ringan

Goroutine adalah fungsi yang berjalan serentak dengan fungsi lain. Ia seperti benang ringan yang diuruskan oleh runtime Go, bukan sistem operasi. Anda memulakan satu dengan kata kunci go :

 pergi dosomething () // berjalan serentak

Berbanding dengan benang OS, goroutine jauh lebih murah:

• Mulakan dengan timbunan kecil (beberapa kb) yang tumbuh seperti yang diperlukan.
• Diuruskan oleh penjadual runtime Go, yang mana goroutine multiplexes ke sebilangan kecil benang OS.
• Tiada Pengurusan Thread Manual -Pembangun tidak bimbang untuk mencipta atau memusnahkan benang.

Ini membolehkan anda menjalankan ribuan atau bahkan berjuta -juta goroutin dengan cekap.

Saluran: Komunikasi antara goroutin

Goroutine tidak berkongsi memori secara langsung. Sebaliknya, pergi mempromosikan idea:

"Jangan berkomunikasi dengan berkongsi ingatan, berkongsi ingatan dengan berkomunikasi."

Saluran adalah cara utama untuk berkomunikasi antara goroutin. Mereka ditaip saluran di mana anda boleh menghantar dan menerima nilai:

 CH: = Buat (chan int)
pergi func () {
    ch <- 42 // hantar
} ()
nilai: = <-ch // terima

Saluran membantu menyelaraskan goroutine dan mengelakkan keadaan kaum. Terdapat dua jenis:

• Saluran Unbuffered : Menyegerakkan penghantar dan penerima (kedua -duanya mesti siap).
• Saluran Buffered : Benarkan beberapa komunikasi tak segerak (sehingga saiz penampan).

Pilih Pernyataan: Saluran Multiplexing

Pernyataan select membolehkan goroutine menunggu operasi saluran berganda:

 pilih {
kes msg1: = <-ch1:
    fmt.println ("diterima", msg1)
Kes CH2 <- "Hi":
    fmt.println ("Dihantar ke CH2")
Lalai:
    FMT.println ("Tiada Komunikasi")
}

Ia seperti switch untuk saluran dan merupakan kunci untuk membina sistem responsif, tidak menyekat.

Contoh dunia nyata: kolam pekerja

 Pekerjaan: = Buat (Chan Int, 100)
Keputusan: = Buat (Chan Int, 100)

// Mula pekerja
untuk w: = 0; W <3; w {
    pergi func () {
        untuk pekerjaan: = julat pekerjaan {
            Hasil <- pekerjaan * 2
        }
    } ()
}

// Hantar pekerjaan
untuk j: = 0; J <5; j {
    Pekerjaan <- j
}
Tutup (Pekerjaan)

// Kumpulkan hasil
untuk a: = 0; A <5; {
    <-results
}

Corak ini adalah perkara biasa dalam pemprosesan serentak seperti pengendalian permintaan web atau tugas latar belakang.

Di bawah tudung: Penjadual Go

Pergi menggunakan m: n penjadual yang memaparkan m goroutines ke benang n os. Dengan ciri seperti:

• Kerja-mencuri : Baki memuatkan teras pemproses.
• Preemption : Menghalang satu goroutine dari kelaparan yang lain.
• Berjalan di GOMAXPROCS (secara lalai, bilangan teras CPU).

Anda tidak perlu menyesuaikan ini untuk kebanyakan aplikasi -ia hanya berfungsi dengan baik dari kotak.

Pada asasnya, Go membuat kesesuaian mudah, selamat, dan berskala dengan menggabungkan goroutine ringan, komunikasi berasaskan saluran, dan penjadual runtime pintar. Ia bukan hanya melakukan perkara -perkara yang selari -ini mengenai menulis kod serentak yang bersih dan boleh dikekalkan.

Atas ialah kandungan terperinci Bagaimanakah pergi mengendalikan kesesuaian?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!