Pengaturcaraan serentak yang cekap: menggunakan Go WaitGroup dan kumpulan coroutine

Pengaturcaraan Serentak yang Cekap: Menggunakan Go WaitGroup dan Coroutine Pool

Pengenalan:
Dalam sistem komputer moden, pengaturcaraan serentak menjadi semakin penting. Pengaturcaraan serentak boleh memaksimumkan penggunaan prestasi pemproses berbilang teras dan meningkatkan kecekapan pelaksanaan program. Walau bagaimanapun, pengaturcaraan serentak juga menghadapi cabaran, seperti menangani penyegerakan dan pengurusan tugas serentak. Dalam artikel ini, kami akan memperkenalkan cara menggunakan WaitGroup dan kumpulan coroutine dalam bahasa Go untuk mencapai pengaturcaraan serentak yang cekap dan menyediakan contoh kod khusus.

1. Penggunaan WaitGroup:
Bahasa Go menyediakan jenis WaitGroup yang sangat berguna, yang boleh digunakan untuk menunggu sekumpulan coroutine menyelesaikan pelaksanaan. Berikut ialah contoh mudah yang menunjukkan cara menggunakan WaitGroup untuk mencapai penyegerakan tugasan serentak:

package main

import (
    "fmt"
    "sync"
)

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()

    fmt.Printf("Worker %d starting
", id)

    // 模拟耗时的任务
    for i := 0; i < 5; i++ {
        fmt.Printf("Worker %d: %d
", id, i)
    }

    fmt.Printf("Worker %d done
", id)
}

func main() {
    var wg sync.WaitGroup

    // 启动5个协程
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go worker(i, &wg)
    }

    // 等待所有协程执行完毕
    wg.Wait()
}

Dalam kod di atas, kami mentakrifkan fungsi pekerja untuk mensimulasikan tugas yang memakan masa. Kami memberitahu WaitGroup bahawa tugas telah selesai dengan menghantar penunjuk ke WaitGroup. Dalam fungsi utama, kami memulakan 5 coroutine dan memaklumkan WaitGroup untuk menambah bilangan tugas menunggu dengan memanggil kaedah wg.Add(1). Akhir sekali, kami memanggil kaedah wg.Wait() untuk menyekat coroutine utama sehingga semua tugasan selesai. wg.Add(1)方法来通知WaitGroup等待的任务数量加一。最后，我们调用wg.Wait()方法来阻塞主协程，直到所有的任务都完成。

二、协程池的使用：
Go语言还提供了协程池的实现，用于限制并发的数量，防止同时运行太多的协程。协程池可以帮助我们平衡系统的资源，并避免资源浪费。下面是一个示例，展示了如何使用协程池来执行任务：

package main

import (
    "fmt"
    "sync"
)

type Pool struct {
    workers chan struct{}
    wg      sync.WaitGroup
}

func NewPool(size int) *Pool {
    return &Pool{
        workers: make(chan struct{}, size),
    }
}

func (p *Pool) AddTask(task func()) {
    p.workers <- struct{}{}
    p.wg.Add(1)

    go func() {
        task()
        <-p.workers
        p.wg.Done()
    }()
}

func (p *Pool) Wait() {
    p.wg.Wait()
}

func main() {
    pool := NewPool(3)

    // 添加10个任务到协程池
    for i := 0; i < 10; i++ {
        taskID := i
        pool.AddTask(func() {
            fmt.Printf("Task %d is running
", taskID)
        })
    }

    // 等待所有任务完成
    pool.Wait()
}

在上述代码中，我们定义了一个Pool结构体，其中包含一个用于限制协程数量的workers通道和一个WaitGroup用于等待所有任务完成。我们通过调用p.workers <- struct{}{}往通道中写入一个空结构体，表示有一个协程正在执行任务；通过<-p.workers从通道中取出一个空结构体，表示一个协程执行完了任务。在AddTask方法中，我们将任务添加到协程池中，并在任务执行完成后从通道中取出一个空结构体。最后，调用pool.Wait()

2. Penggunaan kumpulan coroutine:

Bahasa Go juga menyediakan pelaksanaan kumpulan coroutine, yang digunakan untuk mengehadkan bilangan concurrency dan menghalang terlalu banyak coroutine daripada berjalan pada masa yang sama. Kumpulan coroutine boleh membantu kami mengimbangi sumber sistem dan mengelakkan pembaziran sumber. Berikut ialah contoh yang menunjukkan cara menggunakan kumpulan coroutine untuk melaksanakan tugas:
rrreee

Dalam kod di atas, kami mentakrifkan struktur Pool yang mengandungi saluran pekerja untuk mengehadkan bilangan coroutine dan WaitGroup untuk menunggu Semua tugasan selesai. Kami menulis struktur kosong ke dalam saluran dengan memanggil p.workers <- struct{}{}, menunjukkan bahawa coroutine sedang melaksanakan tugas dengan memanggil <-p.workers Alih keluar struktur kosong daripada saluran, menunjukkan bahawa coroutine telah menyelesaikan tugasnya. Dalam kaedah AddTask, kami menambah tugas pada kumpulan coroutine dan mengeluarkan struktur kosong daripada saluran selepas pelaksanaan tugas selesai. Akhir sekali, panggil kaedah pool.Wait() untuk menunggu semua tugasan selesai. 🎜🎜Kesimpulan: 🎜Dengan menggunakan WaitGroup dan kumpulan coroutine, kami boleh mencapai pengaturcaraan serentak yang cekap dengan mudah. WaitGroup membantu kami menyegerakkan pelaksanaan tugas serentak, manakala kumpulan coroutine mengehadkan bilangan konkurensi dan meningkatkan penggunaan sumber sistem. Dalam aplikasi sebenar, kita boleh melaraskan saiz kolam coroutine mengikut keperluan untuk menggunakan sepenuhnya prestasi komputer. 🎜

Atas ialah kandungan terperinci Pengaturcaraan serentak yang cekap: menggunakan Go WaitGroup dan kumpulan coroutine. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!