Perbandingan coroutine dan urutan dalam bahasa Go

Dalam bahasa Go, Goroutine dan Thread ialah kedua-dua mekanisme yang digunakan untuk menjalankan kod serentak. Walaupun fungsi mereka serupa, terdapat beberapa perbezaan dalam pelaksanaan dan penggunaannya. Artikel ini akan meneroka perbezaan antara coroutine dan urutan dalam bahasa Go melalui contoh kod tertentu dan membantu pembaca memahami dengan lebih baik perbezaan antara mereka.

1. Konsep coroutine dan thread

Coroutine ialah unit concurrency ringan dalam bahasa Go dan boleh dianggap sebagai thread ringan. Coroutine diuruskan oleh masa jalan Go dan mempunyai ruang tindanan yang kecil dan overhed penciptaan dan pemusnahan yang rendah, membolehkan sejumlah besar coroutine dibuat untuk pelaksanaan serentak tanpa perlu risau tentang pembaziran sumber.

Thread ialah unit pelaksanaan serentak di peringkat sistem pengendalian dan diuruskan oleh kernel sistem pengendalian. Setiap utas mempunyai ruang tindanan dan daftar tersendiri Penciptaan dan pemusnahan utas adalah mahal, jadi mustahil untuk mencipta sejumlah besar utas pelaksanaan serentak seperti coroutine.

2. Contoh penggunaan coroutine

Berikut ialah contoh kod mudah penggunaan coroutine:

package main

import (
    "fmt"
    "time"
)

func printNumbers() {
    for i := 1; i <= 5; i++ {
        fmt.Println(i)
    }
}

func main() {
    go printNumbers()
    
    time.Sleep(1 * time.Second)
    fmt.Println("Main goroutine exits")
}

Dalam kod di atas, fungsi printNumbers dimulakan sebagai coroutine, Fungsi ini akan cetak nombor 1 hingga 5. Dalam fungsi utama, gunakan kata kunci go untuk memulakan coroutine printNumbers dan biarkan fungsi utama menunggu selama 1 saat melalui time.Sleep Pastikan coroutine mempunyai masa yang mencukupi untuk dilaksanakan. Akhirnya, fungsi utama mengeluarkan "Keluar goroutine utama". printNumbers函数被启动为一个协程，该函数会打印1到5这几个数字。在主函数中，使用go关键字启动了printNumbers协程，并且通过time.Sleep函数让主函数等待1秒，以确保协程有足够的时间执行。最后主函数输出"Main goroutine exits"。

3. 使用线程的示例

下面是一个简单的使用线程的示例代码：

package main

import (
    "fmt"
    "sync"
)

var wg sync.WaitGroup

func printNumbers() {
    defer wg.Done()

    for i := 1; i <= 5; i++ {
        fmt.Println(i)
    }
}

func main() {
    wg.Add(1)
    go printNumbers()

    wg.Wait()
    fmt.Println("Main thread exits")
}

在上面的代码中，printNumbers函数被启动为一个线程，使用sync.WaitGroup来等待线程的结束。在主函数中，通过wg.Add来添加一个等待的线程，然后通过go关键字启动printNumbers线程。最后通过wg.Wait函数等待线程结束，并输出"Main thread exits"。

4. 区别与总结

从以上的示例可以看出，使用协程需要通过go关键字来启动，并且不需要显式等待协程结束；而使用线程则需使用一些同步机制（比如sync.WaitGroup

3 Contoh penggunaan benang

Atas ialah kandungan terperinci Perbandingan coroutine dan urutan dalam bahasa Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!