Kerjasama antara coroutine Golang dan saluran

Kerjasama coroutine dan Channels dapat merealisasikan pengaturcaraan serentak dan meningkatkan prestasi program dan throughput Melalui Channels, coroutines boleh berkomunikasi dan bertukar data dengan selamat dan cekap Langkah-langkah utama adalah seperti berikut: Buat Saluran untuk menerima tugas. Mulakan berbilang coroutine untuk menerima dan memproses tugasan daripada Saluran. Buat tugasan pada urutan utama dan hantar ke Saluran. Menutup Saluran memberitahu coroutine bahawa tiada lagi tugasan. Gunakan sync.WaitGroup untuk menunggu semua coroutine selesai.

Kerjasama antara Golang coroutine dan Channel

Pengenalan

Coroutine ialah benang ringan mod pengguna Berbanding dengan proses atau utas, penciptaan dan pemusnahan coroutine menggunakan lebih sedikit sumber. Saluran ialah mekanisme dalam bahasa Go untuk komunikasi antara goroutine. Gabungan coroutine dan saluran boleh melaksanakan pengaturcaraan serentak, dengan itu meningkatkan prestasi program dan pemprosesan.

Kes Praktikal

Mari kami menggunakan kes praktikal untuk menunjukkan kerjasama antara coroutine dan saluran. Kes ini akan menunjukkan cara memproses satu set tugasan secara selari.

// 任务定义
type Task struct {
    ID   int
    Data []int
}

// 任务处理函数
func processTask(task *Task) {
    // 耗时处理
    fmt.Printf("Processing task %d\n", task.ID)
    time.Sleep(time.Second * 2)
}

func main() {
    // 创建一个 channel 用于接收任务
    tasks := make(chan *Task, 10)

    // 启动 4 个协程来处理任务
    for i := 0; i < 4; i++ {
        go func() {
            for {
                // 从 channel 中接收任务
                task := <-tasks

                // 处理任务
                processTask(task)
            }
        }()
    }

    // 创建任务并将其发送到 channel
    for i := 0; i < 10; i++ {
        task := &Task{
            ID:   i,
            Data: []int{i, i + 1, i + 2},
        }
        tasks <- task
    }

    // 关闭 channel 告知协程没有更多任务
    close(tasks)

    // 等待所有协程完成
    var wg sync.WaitGroup
    wg.Add(4)
    for i := 0; i < 4; i++ {
        go func() {
            // 协程退出时通知WaitGroup
            wg.Done()
        }()
    }
    wg.Wait()
}

Proses menjalankan kod:

1. Buat saluran tugas untuk menerima tugasan. tasks 用于接收任务。
2. 启动 4 个协程，每个协程都从 channel 中接收任务并进行处理。
3. 在主线程中创建 10 个任务并发送到 channel。
4. 关闭 channel 告知协程没有更多任务。
5. 使用 sync.WaitGroup
Mulakan 4 coroutine, setiap coroutine menerima tugasan daripada saluran dan memprosesnya.

Buat 10 tugasan dalam utas utama dan hantarnya ke saluran.

Tutup saluran untuk memberitahu coroutine bahawa tiada tugas lagi.

🎜Gunakan sync.WaitGroup untuk menunggu semua coroutine selesai. 🎜🎜🎜Ringkasan🎜🎜Gabungan coroutine dan saluran boleh mencapai pengaturcaraan serentak, sekali gus meningkatkan prestasi dan pemprosesan program. Dengan menggunakan saluran, coroutine boleh berkomunikasi dan bertukar data dengan selamat dan cekap. Ini berguna untuk mengendalikan sejumlah besar tugas atau senario yang memerlukan pemprosesan selari. 🎜

Atas ialah kandungan terperinci Kerjasama antara coroutine Golang dan saluran. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!