Apakah amalan terbaik di Golang untuk menjejak status penyiapan dua Goroutine dalam Goroutine ketiga?

Apakah amalan terbaik di Golang untuk menjejak status penyiapan dua Goroutine dalam Goroutine ketiga? Di Golang, untuk menjejak status penyiapan dua Goroutine dan memproses keputusan mereka dalam Goroutine ketiga, amalan terbaik ialah menggunakan WaitGroup daripada pakej penyegerakan. WaitGroup membolehkan kami menunggu di Goroutine utama untuk menyiapkan Goroutine lain. Pertama, kita perlu mencipta objek WaitGroup dan memanggil kaedah Tambah dalam Goroutine utama untuk menetapkan bilangan Goroutine yang menunggu. Kemudian, kaedah Selesai dipanggil pada penghujung setiap Goroutine untuk menandakan siapnya Goroutine tersebut. Akhir sekali, kaedah Tunggu dipanggil dalam Goroutine ketiga untuk menunggu semua Goroutine selesai. Dengan cara ini, kami boleh menjejak dan memproses hasil kedua-dua Goroutine dengan selamat. Ini ialah amalan terbaik di Golang untuk menjejak status penyiapan berbilang Goroutine.

Kandungan soalan

Saya mempunyai tiga gorout berjalan serentak. Dua daripada mereka melakukan beberapa pemprosesan dan menghantar hasil mereka ke saluran hasil. Goroutine ketiga "mengira" keputusan dengan membaca saluran hasil. Saya boleh menggunakan kumpulan tunggu untuk menunggu dua gorout pengiraan selesai dan kemudian melelang ke atas saluran hasil untuk mengira keputusan, tetapi ini tidak berskala dan memerlukan saya membuat saluran hasil penimbal dengan saiz penimbal yang besar, yang tidak boleh diterima dalam kod pengeluaran.

Saya ingin mengira keputusan semasa pemprosesan sedang berlaku, tetapi saya tidak mahu keluar dari program sebelum semua pengiraan selesai. Apakah amalan terbaik untuk mencapai perkara ini dalam Go?

Ini adalah kaedah semasa saya dan ia berfungsi dengan baik. Saya tertanya-tanya sama ada terdapat cara yang lebih baik kerana ini kelihatan agak kikuk?

package main

import (
    "fmt"
    "sync"
)

type T struct{}

func main() {
    var widgetInventory int = 1000
    transactions := make(chan int, 100)
    salesDone := make(chan T)
    purchasesDone := make(chan T)
    var wg sync.WaitGroup
    fmt.Println("Starting inventory count = ", widgetInventory)

    go makeSales(transactions, salesDone)
    go newPurchases(transactions, purchasesDone)

    wg.Add(1)

    go func() {
        salesAreDone := false
        purchasesAreDone := false

        for {
            select {
            case transaction := <-transactions:
                widgetInventory += transaction
            case <-salesDone:
                salesAreDone = true
            case <-purchasesDone:
                purchasesAreDone = true
            default:
                if salesAreDone && purchasesAreDone {
                    wg.Done()
                    return
                }
            }
        }
    }()

    wg.Wait()
    fmt.Println("Ending inventory count = ", widgetInventory)
}

func makeSales(transactions chan int, salesDone chan T) {
    for i := 0; i < 3000; i++ {
        transactions <- -100
    }

    salesDone <- struct{}{}
}

func newPurchases(transactions chan int, purchasesDone chan T) {
    for i := 0; i < 3000; i++ {
        transactions <- 100
    }

    purchasesDone <- struct{}{}
}

Penyelesaian

tidak menepati sebarang definisi munasabahbaik. Anda mempunyai gelung for yang popular di sini:

for {
            select {
            case transaction := <-transactions:
                widgetInventory += transaction
            case <-salesDone:
                salesAreDone = true
            case <-purchasesDone:
                purchasesAreDone = true
            default:
                if salesAreDone && purchasesAreDone {
                    wg.Done()
                    return
                }
            }
        }

Selagi tiada saluran untuk dibaca, kes default akan dilaksanakan. Ini banyak berlaku kerana cara saluran berfungsi.

Versi kod yang dilaraskan sedikit ini menggambarkan "panas" gelung ini. Hasil yang tepat akan berbeza-beza dan mungkin agak tinggi.

Default case ran 27305 times

Anda tidak mahu kes selecting 来自通道时，您不希望出现 default apabila memilihdari saluran, melainkan lalai itu turut menyekat sesuatu di dalamnya. Jika tidak, anda akan mendapat kitaran haba seperti ini.

Cara yang lebih baik: gunakan nilsaluran yang boleh untuk pemilihan

Biasanya dalam pilihan, anda ingin mengenal pasti saluran tertutup dan menetapkan pembolehubah saluran kepada nil； select 永远不会成功地从 nil

go func(transactions chan int, salesDone <-chan T, purchasesDone <-chan T) {
        defer wg.Done()
        for transactions != nil {
            select {
            case transaction, ok := <-transactions:
                if ok {
                    widgetInventory += transaction
                } else {
                    transactions = nil
                }
            case <-salesDone:
                salesDone = nil
                if purchasesDone == nil {
                    close(transactions)
                }
            case <-purchasesDone:
                purchasesDone = nil
                if salesDone == nil {
                    close(transactions)
                }

            }
        }
    }(transactions, salesDone, purchasesDone)

package main

import (
    "fmt"
    "sync"
)

func main() {
    var widgetInventory int = 1000
    transactions := make(chan int, 100)

    var wg, resultswg sync.WaitGroup
    fmt.Println("Starting inventory count = ", widgetInventory)
    wg.Add(2)

    go makeSales(transactions, &wg)
    go newPurchases(transactions, &wg)
    resultswg.Add(1)
    go func() {
        defer resultswg.Done()
        for transaction := range transactions {
            widgetInventory += transaction
        }
    }()

    wg.Wait()
    close(transactions)
    resultswg.Wait()
    fmt.Println("Ending inventory count = ", widgetInventory)
}

func makeSales(transactions chan int, wg *sync.WaitGroup) {
    defer wg.Done()
    for i := 0; i < 3000; i++ {
        transactions <- -100
    }

}

func newPurchases(transactions chan int, wg *sync.WaitGroup) {
    defer wg.Done()
    for i := 0; i < 3000; i++ {
        transactions <- 100
    }

}