Memahami Goroutines

Go menonjol kerana keupayaannya membina aplikasi bersaing dengan mudah dan cekap. Salah satu ciri yang menjadikannya seperti ini ialah Goroutines, salah satu ciri bahasa yang paling berkuasa. Jika anda pernah menggunakan bahasa lain, anda mungkin biasa dengan urutan, tetapi Goroutine berbeza.

Apakah itu Goroutine?

Ringkasnya, ia adalah fungsi atau kaedah yang berjalan serentak dengan fungsi atau kaedah lain. Ia lebih ringan daripada urutan OS, jadi anda boleh mencipta beribu-ribu Goroutine dengan lebih sedikit overhed.

Apakah Benang dan mengapa Goroutine boleh menjadi lebih ringan?

Benang pada asasnya ialah unit pelaksanaan dalam proses. Suatu proses boleh mempunyai berbilang benang, semuanya berkongsi ruang memori yang sama tetapi dengan timbunan pelaksanaannya sendiri, yang pada asasnya merupakan struktur data yang menyimpan maklumat tentang fungsi aktif dalam program. Urutan OS diurus dan diskalakan oleh OS, dan juga mempunyai had praktikal ribuan utas setiap proses dan saiz tindanan tetap (biasanya 1MB atau lebih setiap utas).

Groutine ialah "benang hijau" atau benang peringkat pengguna, diuruskan oleh masa jalan Go, saiz tindanan dinamik bermula pada hanya 2KB dan boleh mengembang atau mengecil mengikut keperluan. Itulah sebabnya Goroutines boleh menjadi lebih ringan.

Apakah Persaingan dan apakah perbezaan daripada Paralelisme?

Concurrency ialah tindakan menangani beberapa tugasan pada masa yang sama, manakala Paralelisme melaksanakan tugas secara serentak pada berbilang pemproses. Agak mengelirukan, tetapi anda akan faham dengan lebih baik sekarang: Persaingan melibatkan lebih banyak struktur dan organisasi. Lihat contoh di bawah:

Paralelisme melibatkan lebih banyak pelaksanaan, sebenarnya berjalan pada masa yang sama, lihat contoh di bawah:

Apakah Saluran?

Saluran ialah "saluran" komunikasi antara Goroutines. Mereka membenarkan Goroutines untuk berkomunikasi dan menyegerakkan pelaksanaan mereka. Contoh komunikasi antara Goroutines menggunakan Saluran:

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

    go func() {
        ch <- "Mensagem da goroutine"
    }()

    msg := <-ch
    fmt.Println(msg)
}

Sekarang mari kita selesaikan dengan contoh penggunaan Goroutines:

// 1. Fazendo café e torrada ao mesmo tempo
func cafeDaManha() {
   fmt.Println("Iniciando café da manhã...") // 1º: Aparece primeiro

   go fazerCafe()    // 2º: "Começando a fazer café..."
   go fazerTorrada() // 3º: "Começando a fazer torrada..."

   // Espera 5 segundos para tudo ficar pronto
   time.Sleep(5 * time.Second)
   fmt.Println("Café da manhã pronto!") // Último: Aparece depois de 5 segundos
}

func fazerCafe() {
   fmt.Println("Começando a fazer café...")
   time.Sleep(3 * time.Second) 
   fmt.Println("Café pronto!") // 4º: Aparece após 3 segundos
}

func fazerTorrada() {
   fmt.Println("Começando a fazer torrada...")
   time.Sleep(2 * time.Second)
   fmt.Println("Torrada pronta!") // 5º: Aparece após 2 segundos
}

/* Saída:
Iniciando café da manhã...
Começando a fazer café...
Começando a fazer torrada...
Torrada pronta! (após 2 segundos)
Café pronto! (após 3 segundos)
Café da manhã pronto! (após 5 segundos)
*/

// 2. Contagem com Goroutines
func contagem() {
   go contar("A", 5) // Começa a contar imediatamente
   go contar("B", 5) // Começa a contar imediatamente

   time.Sleep(6 * time.Second)
}

func contar(nome string, até int) {
   for i := 1; i <= até; i++ {
       fmt.Printf("%s: %d\n", nome, i)
       time.Sleep(1 * time.Second)
   }
}

/* Saída (aproximada - as linhas A e B se misturam):
A: 1
B: 1
A: 2
B: 2
A: 3
B: 3
A: 4
B: 4
A: 5
B: 5
*/

// 3. Enviando mensagens simples
func mensagens() {
   canal := make(chan string)

   go func() {
       canal <- "Olá!"      // 1ª mensagem enviada
       canal <- "Tudo bem?" // 2ª mensagem enviada
       canal <- "Tchau!"    // 3ª mensagem enviada
   }()

   fmt.Println(<-canal) // 1º: Imprime "Olá!"
   fmt.Println(<-canal) // 2º: Imprime "Tudo bem?"
   fmt.Println(<-canal) // 3º: Imprime "Tchau!"
}

/* Saída:
Olá!
Tudo bem?
Tchau!
*/

Atas ialah kandungan terperinci Memahami Goroutines. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!