Memahami Goroutine dan Saluran di Golang dengan Visual Intuitif

⚠️ Bagaimana untuk meneruskan siri ini?

1. Jalankan Setiap Contoh: Jangan baca kod sahaja. Taipkannya, jalankan dan perhatikan tingkah lakunya.
2. Eksperimen dan Pecah Perkara: Alih keluar tidur dan lihat apa yang berlaku, tukar saiz penimbal saluran, ubah suai kiraan goroutine.
Memecahkan perkara mengajar anda cara ia berfungsi
3. Sebab Tentang Gelagat: Sebelum menjalankan kod yang diubah suai, cuba ramalkan hasilnya. Apabila anda melihat tingkah laku yang tidak dijangka, berhenti seketika dan fikirkan mengapa. Cabar penjelasan.
4. Bina Model Mental: Setiap visualisasi mewakili konsep. Cuba lukis gambar rajah anda sendiri untuk kod yang diubah suai.

Ini adalah bahagian 1 siri "Mastering Go Concurrency" kami di mana kami akan membincangkan:

• Cara goroutine berfungsi dan kitaran hayatnya
• Saluran komunikasi antara gorouti
• Saluran buffer dan kes penggunaannya
• Contoh dan visualisasi praktikal

Kami akan bermula dengan asas-asas dan secara progresif bergerak ke hadapan membangunkan gerak hati tentang cara menggunakannya dengan berkesan.

Ia akan menjadi agak lama, agak lama jadi bersiap sedia.

kami akan membantu sepanjang proses itu.

Asas Goroutines

Mari kita mulakan dengan program ringkas yang memuat turun berbilang fail.

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    startTime := time.Now()

    downloadFile("file1.txt")
    downloadFile("file2.txt")
    downloadFile("file3.txt")

    elapsedTime := time.Since(startTime)

    fmt.Printf("All downloads completed! Time elapsed: %s\n", elapsedTime)
}

Program ini mengambil masa 6 saat kerana setiap muat turun 2 saat mesti selesai sebelum yang seterusnya bermula. Mari kita bayangkan ini:

Kita boleh turunkan kali ini, mari kita ubah suai program kita untuk menggunakan go rutin:

notis: pergi kata kunci sebelum panggilan fungsi

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    // Launch downloads concurrently
    go downloadFile("file1.txt")
    go downloadFile("file2.txt")
    go downloadFile("file3.txt")

    fmt.Println("All downloads completed!")
}

tunggu apa? tiada apa yang dicetak? Kenapa?

Mari kita bayangkan perkara ini untuk memahami perkara yang mungkin berlaku.

daripada visualisasi di atas, kami faham bahawa fungsi utama wujud sebelum goroutine selesai. Satu pemerhatian ialah semua kitaran hayat goroutine bergantung pada fungsi utama.

Nota: fungsi utama itu sendiri ialah goroutine ;)

Untuk membetulkan perkara ini, kami memerlukan satu cara untuk membuat goroutine utama menunggu goroutine lain selesai. Terdapat beberapa cara untuk melakukan ini:

1. tunggu beberapa saat (cara meretas)
2. Menggunakan WaitGroup (cara yang betul, seterusnya)
3. Menggunakan saluran (kami akan membincangkannya di bawah)

Mari tunggu beberapa saat untuk rutin perjalanan selesai.

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    startTime := time.Now()

    downloadFile("file1.txt")
    downloadFile("file2.txt")
    downloadFile("file3.txt")

    elapsedTime := time.Since(startTime)

    fmt.Printf("All downloads completed! Time elapsed: %s\n", elapsedTime)
}

Masalah dengan ini ialah, kita mungkin tidak tahu berapa lama masa goroutine mungkin diambil. Dalam kes ini, kami mempunyai masa yang tetap untuk setiap satu tetapi dalam senario sebenar kami sedar bahawa masa muat turun berbeza-beza.

Datang penyegerakan.WaitGroup

Penyegerakan.WaitGroup dalam Go ialah mekanisme kawalan serentak yang digunakan untuk menunggu koleksi goroutin selesai dilaksanakan.

mari kita lihat ini dalam tindakan dan gambarkan:

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    // Launch downloads concurrently
    go downloadFile("file1.txt")
    go downloadFile("file2.txt")
    go downloadFile("file3.txt")

    fmt.Println("All downloads completed!")
}

Mari kita bayangkan perkara ini dan fahami kerja penyegerakan.WaitGroup:

Mekanisme Kaunter:

• WaitGroup mengekalkan kaunter dalaman
• wg.Add(n) menambah pembilang sebanyak n
• wg.Done() mengurangkan kaunter sebanyak 1
• wg.Wait() blok sehingga kaunter mencapai 0

Aliran Penyegerakan:

• Panggilan goroutine utama Tambah(3) sebelum melancarkan goroutin
• Setiap goroutine memanggil Selesai() apabila ia selesai
• Groutine utama disekat di Wait() sehingga kaunter mencecah 0
• Apabila kaunter mencapai 0, program diteruskan dan keluar dengan bersih

Perangkap biasa yang perlu dielakkan

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    startTime := time.Now() // Record start time

    go downloadFile("file1.txt")
    go downloadFile("file2.txt")
    go downloadFile("file3.txt")

    // Wait for goroutines to finish
    time.Sleep(3 * time.Second)

    elapsedTime := time.Since(startTime)

    fmt.Printf("All downloads completed! Time elapsed: %s\n", elapsedTime)
}

Saluran

Jadi kami mendapat pemahaman yang baik tentang cara goroutine berfungsi. Tidak, bagaimanakah dua rutin pergi berkomunikasi? Di sinilah saluran masuk.

Saluran dalam Go ialah primitif serentak berkuasa yang digunakan untuk komunikasi antara goroutin. Mereka menyediakan cara untuk gorout berkongsi data dengan selamat.

Fikirkan saluran sebagai paip: satu goroutine boleh menghantar data ke saluran, dan yang lain boleh menerimanya.

berikut adalah beberapa sifat:

1. Saluran disekat secara semula jadi.
2. Satu hantar ke saluran operasi ch <- nilai sekat sehingga beberapa goroutine lain menerima daripada saluran.
3. Sebuah terima daripada saluran operasi <-ch sekat sehingga beberapa goroutine lain dihantar ke saluran.

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    startTime := time.Now()

    downloadFile("file1.txt")
    downloadFile("file2.txt")
    downloadFile("file3.txt")

    elapsedTime := time.Since(startTime)

    fmt.Printf("All downloads completed! Time elapsed: %s\n", elapsedTime)
}

mengapa ch <- "hello" akan menyebabkan kebuntuan? Memandangkan saluran menyekat secara semula jadi dan di sini kami menghantar "hello" ia akan menyekat goroutine utama sehingga ada penerima dan kerana tiada penerima jadi ia akan tersekat.

Mari kita selesaikan perkara ini dengan menambah goroutine

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    // Launch downloads concurrently
    go downloadFile("file1.txt")
    go downloadFile("file2.txt")
    go downloadFile("file3.txt")

    fmt.Println("All downloads completed!")
}

Mari kita bayangkan ini:

Mesej kali ini sedang dihantar daripada goroutine yang berbeza supaya yang utama tidak disekat semasa menghantar ke saluran supaya ia bergerak ke msg := <-ch di mana ia menyekat goroutine utama sehingga ia menerima mesej.

Membaiki utama tidak menunggu isu lain menggunakan saluran

Sekarang mari kita gunakan saluran untuk membetulkan isu pemuat turun fail (utama tidak menunggu orang lain selesai).

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    startTime := time.Now() // Record start time

    go downloadFile("file1.txt")
    go downloadFile("file2.txt")
    go downloadFile("file3.txt")

    // Wait for goroutines to finish
    time.Sleep(3 * time.Second)

    elapsedTime := time.Since(startTime)

    fmt.Printf("All downloads completed! Time elapsed: %s\n", elapsedTime)
}

membayangkannya:

Jom buat larian kering untuk lebih faham:

Permulaan Program:

Groutine utama mencipta saluran siap
Melancarkan tiga goroutine muat turun
Setiap goroutine mendapat rujukan kepada saluran yang sama

Muat Turun Perlaksanaan:

1. Ketiga-tiga muat turun dijalankan serentak
2. Setiap satu mengambil masa 2 saat
3. Mereka mungkin selesai dalam sebarang urutan

Gelung Saluran:

1. Groutine utama memasuki gelung: untuk i := 0; i < 3; i
2. Setiap <-selesai menyekat sehingga nilai diterima
3. Gelung memastikan kami menunggu ketiga-tiga isyarat siap

Gelagat Gelung:

1. Lelaran 1: Sekat sehingga muat turun pertama selesai
2. Lelaran 2: Sekat sehingga muat turun kedua selesai
3. Lelaran 3: Sekat sehingga muat turun akhir selesai

Tertib penyiapan tidak penting!

Pemerhatian:
⭐ Setiap hantaran (selesai <- benar) mempunyai tepat satu penerimaan (<-selesai)
⭐ Goroutin utama menyelaraskan segala-galanya melalui gelung

Bagaimanakah dua goroutine boleh berkomunikasi?

Kami telah melihat bagaimana dua goroutine boleh berkomunikasi. bila? Selama ini. Jangan lupa fungsi utama juga merupakan goroutine.

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    startTime := time.Now()

    downloadFile("file1.txt")
    downloadFile("file2.txt")
    downloadFile("file3.txt")

    elapsedTime := time.Since(startTime)

    fmt.Printf("All downloads completed! Time elapsed: %s\n", elapsedTime)
}

Mari kita bayangkan ini dan jalankan kering ini:

larian kering:

Permulaan Program (t=0ms)

• Groutine utama memulakan tiga saluran:
  • ch: untuk mesej.
  • pengirimSelesai: untuk menandakan penghantar selesai.
  • penerimaSelesai: untuk memberi isyarat kepada penerima selesai.
• Groutine utama melancarkan dua goroutine:
  • penghantar.
  • penerima.
• Sekat goroutine utama, menunggu isyarat daripada <-senderDone.

Mesej Pertama (t=1ms)

1. Penghantar menghantar "mesej 1" ke saluran ch.
2. Penerima bangun dan memproses mesej:
   • Cetakan: "Diterima: mesej 1".
3. Penghantar tidur selama 100ms.

Mesej Kedua (t=101ms)

1. Penghantar bangun dan menghantar "mesej 2" ke saluran ch.
2. Penerima memproses mesej:
   • Cetakan: "Diterima: mesej 2".
3. Pengirim tidur selama 100ms lagi.

Mesej Ketiga (t=201ms)

1. Penghantar bangun dan menghantar "mesej 3" ke saluran ch.
2. Penerima memproses mesej:
   • Cetakan: "Diterima: mesej 3".
3. Penghantar tidur untuk kali terakhir.

Penutup Saluran (t=301ms)

1. Penghantar selesai tidur dan menutup saluran ch.
2. Penghantar menghantar isyarat benar kepada saluran penghantarSelesai untuk menunjukkan selesai.
3. Penerima mengesan bahawa saluran ch telah ditutup.
4. Penerima keluar dari gelung jarak jauhnya.

Penyelesaian (t=302-303ms)

1. Groutine utama menerima isyarat daripada pengirimSelesai dan berhenti menunggu.
2. Groutine utama mula menunggu isyarat daripada penerimaSelesai.
3. Penerima menghantar isyarat penyiapan ke saluran penerimaSelesai.
4. Groutine utama menerima isyarat dan mencetak:
   • "Semua operasi selesai!".
5. Atur cara keluar.

Saluran Penampan

Mengapa kita memerlukan saluran penimbal?
Saluran tidak buffer menyekat kedua-dua penghantar dan penerima sehingga pihak lain bersedia. Apabila komunikasi frekuensi tinggi diperlukan, saluran tidak buffer boleh menjadi halangan kerana kedua-dua gorouti mesti berhenti seketika untuk bertukar data.

Sifat saluran buffer:

1. FIFO (Masuk Pertama, Keluar Dahulu, serupa dengan baris gilir)
2. Saiz tetap, ditetapkan pada penciptaan
3. Sekat penghantar apabila penimbal penuh
4. Sekat penerima apabila penimbal kosong

Kami melihatnya dalam tindakan:

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    startTime := time.Now()

    downloadFile("file1.txt")
    downloadFile("file2.txt")
    downloadFile("file3.txt")

    elapsedTime := time.Since(startTime)

    fmt.Printf("All downloads completed! Time elapsed: %s\n", elapsedTime)
}

output (sebelum menyahkomen ch<-"ketiga")

Mengapa ia tidak menyekat goroutine utama?

1. Saluran penimbal membolehkan penghantaran sehingga kapasitinya tanpa menyekat pengirim.

2. Saluran ini mempunyai kapasiti 2, bermakna ia boleh menyimpan dua nilai dalam penimbalnya sebelum menyekat.

3. Penimbal sudah penuh dengan "pertama" dan "kedua." Memandangkan tiada penerima serentak untuk menggunakan nilai ini, operasi hantar disekat selama-lamanya.

4. Oleh kerana goroutine utama juga bertanggungjawab untuk menghantar dan tiada goroutine aktif lain untuk menerima nilai daripada saluran, program mengalami kebuntuan apabila cuba menghantar mesej ketiga.

Menyahtanda mesej ketiga membawa kepada kebuntuan kerana kapasiti penuh sekarang dan mesej ke-3 akan disekat sehingga penimbal dibebaskan.

Bila hendak menggunakan saluran Penimbalan vs saluran Tidak Penimbalan

Aspect	Buffered Channels	Unbuffered Channels
Purpose	For decoupling sender and receiver timing.	For immediate synchronization between sender and receiver.
When to Use	- When the sender can proceed without waiting for receiver.	- When sender and receiver must synchronize directly.
	- When buffering improves performance or throughput.	- When you want to enforce message-handling immediately.
Blocking Behavior	Blocks only when buffer is full.	Sender blocks until receiver is ready, and vice versa.
Performance	Can improve performance by reducing synchronization.	May introduce latency due to synchronization.
Example Use Cases	- Logging with rate-limited processing.	- Simple signaling between goroutines.
	- Batch processing where messages are queued temporarily.	- Hand-off of data without delay or buffering.
Complexity	Requires careful buffer size tuning to avoid overflows.	Simpler to use; no tuning needed.
Overhead	Higher memory usage due to the buffer.	Lower memory usage; no buffer involved.
Concurrency Pattern	Asynchronous communication between sender and receiver.	Synchronous communication; tight coupling.
Error-Prone Scenarios	Deadlocks if buffer size is mismanaged.	Deadlocks if no goroutine is ready to receive or send.

Pengambilan utama

Gunakan Ditimpan Saluran jika:

1. Anda perlu memisahkan masa pengirim dan penerima.
2. Prestasi boleh mendapat manfaat daripada menyusun atau beratur mesej.
3. Aplikasi boleh bertolak ansur dengan kelewatan dalam memproses mesej apabila penimbal penuh.

Gunakan Unbuffered Saluran jika:

1. Penyegerakan adalah kritikal antara gorouti.
2. Anda mahukan kesederhanaan dan penyerahan data segera.
3. Interaksi antara penghantar dan penerima mesti berlaku serta-merta.

---

Asas ini menetapkan peringkat untuk konsep yang lebih maju. Dalam siaran kami yang akan datang, kami akan meneroka:

Catatan Seterusnya:

1. Corak Konkurensi
2. Mutex dan Penyegerakan Memori

Nantikan semasa kami terus membina pemahaman kami tentang ciri konkurensi yang berkuasa Go!

Atas ialah kandungan terperinci Memahami Goroutine dan Saluran di Golang dengan Visual Intuitif. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!