Ketahui cara mereka bentuk Select Channels Go yang boleh berskala pengaturcaraan serentak dalam golang

Ketahui cara mereka bentuk Select Channels Go yang boleh berskala pengaturcaraan serentak dalam golang

Pengenalan:

Bahasa Go ialah bahasa pengaturcaraan serentak yang cekap dan padat, dan model konkurensinya terutamanya berdasarkan goroutine dan saluran. Melalui mekanisme komunikasi intuitif benang dan saluran ringan goroutines, model pengaturcaraan serentak bahasa Go menyediakan cara yang cekap untuk mengendalikan tugas serentak.

Dalam bahasa Go, adalah perkara biasa untuk menggunakan saluran untuk komunikasi. Sebagai tambahan kepada penggunaan asas saluran, kami juga boleh menggunakan penyata terpilih untuk mengendalikan pemilihan dan komunikasi berbilang saluran untuk mencapai pengaturcaraan serentak yang lebih fleksibel dan berskala.

Artikel ini akan mengambil contoh sebagai contoh untuk memperkenalkan cara menggunakan penyataan dan saluran terpilih untuk mereka bentuk program serentak berskala.

Kes:

Kami mengandaikan terdapat pengedar tugas, dan beberapa utas pekerja mendapat tugas daripada pengedar tugas untuk diproses. Penghantar tugas melaraskan strategi peruntukan tugas secara dinamik berdasarkan panjang baris gilir tugas dan bilangan rangkaian pekerja.

Pertama, kami mentakrifkan struktur tugas Tugas:

type Task struct {
    ID    int
    Value int
}

Seterusnya, kami mencipta Pengedar tugasan dan melaksanakan kaedah berkaitan:

type Dispatcher struct {
    workerCount  int
    taskQueue    chan Task
    workerDone   chan struct{}
    workerFinish chan struct{}
}

func NewDispatcher(workerCount int) *Dispatcher {
    return &Dispatcher{
        workerCount:  workerCount,
        taskQueue:    make(chan Task),
        workerDone:   make(chan struct{}, workerCount),
        workerFinish: make(chan struct{}),
    }
}

func (d *Dispatcher) Start() {
    for i := 0; i < d.workerCount; i++ {
        go d.worker()
    }

    go d.adjust()
}

func (d *Dispatcher) worker() {
    for task := range d.taskQueue {
        // 处理任务
        fmt.Printf("Worker[%d] processing task %d
", task.ID, task.Value)
        time.Sleep(1 * time.Second)
        d.workerDone <- struct{}{}
    }
}

func (d *Dispatcher) adjust() {
    for {
        select {
        case <-d.workerFinish:
            d.workerCount--
            if d.workerCount == 0 {
                return
            }
        case <-time.After(5 * time.Second):
            if len(d.taskQueue) > 10 && d.workerCount < 5 {
                d.workerCount++
                go d.worker()
            }
        }
    }
}

func (d *Dispatcher) Dispatch(task Task) {
    d.taskQueue <- task
}

func (d *Dispatcher) Wait() {
    for i := 0; i < d.workerCount; i++ {
        <-d.workerDone
    }
    close(d.taskQueue)
    close(d.workerFinish)
    close(d.workerDone)
}

Dalam Dispatcher kami mentakrifkan 4 saluran: taskQueue untuk penerimaan dan pengagihan tugas, workerDone digunakan untuk pemulangan isyarat selesai tugas, dan workerFinish digunakan untuk mengira dan melaraskan benang pekerja.

Kaedah mula digunakan untuk memulakan utas pekerja dan utas pelarasan tugas, di mana kaedah pekerja ialah pelaksanaan khusus bagi utas pekerja. Setiap urutan pekerja mengeluarkan tugas daripada taskQueue untuk diproses dan menghantar isyarat penyiapan tugas kepada workerDone. Kaedah

melaraskan ialah pelaksanaan khusus bagi utas pelarasan tugas. Ia menggunakan pilih untuk memantau dua saluran Apabila workerFinish menerima isyarat, ini bermakna benang pekerja telah menyelesaikan tugas dan pelarasan kakitangan perlu dibuat. Apabila masa.Selepas pemasa dicetuskan, ini bermakna panjang giliran tugasan terlalu panjang dan benang pekerja perlu ditambah untuk mengendalikan lebih banyak tugas. Dengan melaraskan bilangan rangkaian pekerja secara dinamik, kami boleh menggunakan sepenuhnya sumber sistem dan memastikan tugasan diproses dengan cepat.

Kaedah Dispatch digunakan untuk menyerahkan tugasan kepada penghantar tugas. Kaedah Tunggu digunakan untuk menunggu selesai semua tugasan.

Contoh penggunaan:

func main() {
    dispatcher := NewDispatcher(3)
    dispatcher.Start()
    
    for i := 0; i < 20; i++ {
        task := Task{
            ID:    i,
            Value: i,
        }
        dispatcher.Dispatch(task)
    }
    
    dispatcher.Wait()
}

Dalam contoh ini, kami mencipta Dispatcher dan memulakan 3 utas pekerja. Kemudian, kami mengagihkan 20 tugasan kepada Dispatcher. Akhir sekali, tunggu sehingga semua tugasan selesai melalui kaedah Tunggu.

Ringkasan:

Dengan menggunakan kenyataan dan saluran terpilih, kami boleh mereka bentuk program serentak berskala secara fleksibel. Dalam kes ini, kami menunjukkan cara menggunakan pilih dan saluran untuk melaksanakan penghantar tugas yang melaraskan strategi pengagihan tugas secara dinamik. Dengan menggunakan kaedah ini, kami boleh menggunakan sepenuhnya sumber sistem dan memastikan tugasan diproses dengan cepat.

Dalam pengaturcaraan serentak sebenar, kami boleh mengembangkan dan mengoptimumkan lagi model ini mengikut keperluan dan senario tertentu. Saya harap artikel ini dapat membantu pembaca memahami dengan lebih baik dan menggunakan saluran pilih dan untuk mereka bentuk program serentak Go berskala.

Atas ialah kandungan terperinci Ketahui cara mereka bentuk Select Channels Go yang boleh berskala pengaturcaraan serentak dalam golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!