Pemprosesan berbilang teras: Menggunakan Go WaitGroup untuk melaksanakan pengkomputeran serentak di Golang

Pemprosesan berbilang teras: Gunakan Go WaitGroup untuk melaksanakan pengkomputeran serentak di Golang

Dalam beberapa dekad yang lalu, kuasa pemprosesan komputer terus bertambah baik, daripada pemproses teras tunggal kepada berbilang teras. Kemunculan pemproses berbilang teras telah membawa keupayaan yang lebih berkuasa kepada pengkomputeran serentak. Untuk memanfaatkan sepenuhnya pemproses berbilang teras, pembangun perlu menggunakan teknik pengaturcaraan serentak yang sesuai. Dalam artikel ini, kami akan memperkenalkan cara menggunakan WaitGroup dalam bahasa Go untuk melaksanakan pengkomputeran serentak untuk pemprosesan berbilang teras dan menyediakan contoh kod khusus.

Bahasa Go ialah bahasa pengaturcaraan taip statik sumber terbuka yang menampilkan pengaturcaraan ringkas, cekap dan serentak. Dalam pustaka standard bahasa Go, jenis WaitGroup disediakan untuk menunggu penghujung kumpulan coroutine (goroutine). WaitGroup menggunakan kaunter secara dalaman untuk melaksanakan fungsi menunggu semua coroutine menyelesaikan pelaksanaan.

Berikut ialah kod sampel untuk pengiraan serentak pemprosesan berbilang teras menggunakan WaitGroup:

package main

import (
    "fmt"
    "sync"
)

func main() {
    // 创建一个WaitGroup
    var wg sync.WaitGroup

    // 定义要计算的数据
    data := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

    // 设置WaitGroup的计数器为要计算的数据的长度
    wg.Add(len(data))

    // 使用多个协程并发计算数据
    for _, num := range data {
        go func(n int) {
            // 在协程结束时减少WaitGroup的计数器
            defer wg.Done()

            // 将数据作为参数传递给计算函数
            result := compute(n)

            // 打印计算结果
            fmt.Printf("计算结果：%d
", result)
        }(num)
    }

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

    fmt.Println("所有计算已完成")
}

// 计算函数
func compute(n int) int {
    // 模拟复杂的计算过程
    result := n * n * n
    return result
}

Dalam kod sampel ini, objek WaitGroup wg pertama kali dibuat. Seterusnya, data yang akan dikira ditakrifkan, mengambil integer dari 1 hingga 10 sebagai contoh. Kemudian, tetapkan pembilang objek WaitGroup kepada panjang data dengan memanggil fungsi wg.Add, menunjukkan bilangan coroutine yang perlu menunggu.

Seterusnya, gunakan gelung for untuk merentasi setiap nilai dalam data dan gunakan kata kunci go untuk mencipta coroutine serentak. Dalam fungsi coroutine, pengiraan fungsi pengiraan dipanggil dan hasil pengiraan dicetak. Pada penghujung fungsi coroutine, pembilang objek WaitGroup dikurangkan sebanyak 1 dengan memanggil fungsi wg.Done, menunjukkan bahawa coroutine telah selesai.

Akhir sekali, dengan memanggil fungsi wg.Wait, coroutine utama akan menunggu sehingga semua coroutine selesai melaksanakan, dan kemudian mengeluarkan "semua pengiraan selesai".

Dengan menggunakan WaitGroup dan berbilang coroutine, kami boleh menggunakan sepenuhnya keupayaan serentak pemproses berbilang teras dan mempercepatkan pengiraan.

Untuk meringkaskan, artikel ini memperkenalkan cara menggunakan WaitGroup dalam bahasa Go untuk melaksanakan pengkomputeran serentak untuk pemprosesan berbilang teras. Melalui contoh kod tertentu, ia menunjukkan cara menggunakan WaitGroup untuk menunggu penghujung coroutine dan menggunakan berbilang coroutine untuk melakukan pengiraan pada masa yang sama. Kaedah ini boleh meningkatkan kecekapan pengkomputeran dan memberikan permainan penuh kepada keupayaan serentak pemproses berbilang teras.

Rujukan:
[1] Spesifikasi Bahasa Pengaturcaraan Go https://golang.org/ref/spec
[2] Bahasa Pengaturcaraan Go https://golang.org/
[3] Corak Go Concurrency : Saluran paip dan pembatalan https://blog.golang.org/pipelines

Atas ialah kandungan terperinci Pemprosesan berbilang teras: Menggunakan Go WaitGroup untuk melaksanakan pengkomputeran serentak di Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!