Penjadual serentak Golang: pelaksanaan dioptimumkan Go WaitGroup

Penjadual serentak Golang: pelaksanaan dioptimumkan Go WaitGroup

Pengenalan:
Bahasa Go menyediakan cara yang mudah untuk menulis program serentak melalui model serentak goroutine dan jenis WaitGroup dalam pakej penyegerakan terbina dalam. Walau bagaimanapun, apabila saiz program meningkat, penggunaan sejumlah besar goroutine dan WaitGroups boleh menyebabkan kesesakan prestasi. Untuk mengoptimumkan masalah ini, artikel ini akan memperkenalkan kaedah yang boleh mengurus tugas serentak dengan lebih cekap.

1. Reka bentuk idea penjadual serentak:
Untuk mengurus tugas serentak dengan lebih baik, kita perlu mereka bentuk penjadual serentak. Penjadual serentak terutamanya merangkumi komponen berikut: baris gilir tugas, kumpulan goroutine, fungsi pelaksanaan tugas dan semaphore. Idea reka bentuk penjadual adalah seperti berikut:
1. Barisan tugasan: digunakan untuk menyimpan tugasan yang akan dilaksanakan dalam bentuk barisan, tugasan dikeluarkan untuk pelaksanaan apabila proses terbiar
2 untuk mengurus bilangan goroutin. Hadkan bilangan goroutin untuk mengelakkan masalah prestasi yang disebabkan oleh penciptaan dan pemusnahan sejumlah besar goroutine
3. Semaphore: digunakan untuk mengawal penjadual Status berjalan memastikan semua tugasan dilaksanakan dan kemudian keluar.

2. Pelaksanaan khusus penjadual serentak:

Berikut ialah contoh kod berdasarkan pelaksanaan pengoptimuman penjadual serentak Golang:

package main

import (
    "fmt"
    "sync"
    "time"
)

// 定义任务结构体
type Task struct {
    TaskID int // 任务ID
}

func main() {
    var (
        tasksNumber = 100 // 待执行任务数量
        goroutineNum = 10 // goroutine数量
        wg sync.WaitGroup
        taskQueue = make(chan Task, tasksNumber) // 任务队列
    )
    // 初始化任务队列
    for i := 0; i < tasksNumber; i++ {
        task := Task{
            TaskID: i,
        }
        taskQueue <- task
    }
    close(taskQueue)

    // 启动goroutine
    for i := 0; i < goroutineNum; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            for task := range taskQueue {
                execute(task)
            }
        }(i)
    }
    wg.Wait()
}

// 任务的具体执行函数
func execute(task Task) {
    fmt.Printf("TaskID: %d, Now: %s
", task.TaskID, time.Now().Format("2006-01-02 15:04:05"))
    time.Sleep(1 * time.Second)
    fmt.Printf("TaskID: %d, Finished
", task.TaskID)
}

Dalam kod di atas, kami mula-mula membuat baris gilir tugas (taskQueue) dan memasukkannya ke dalam ia untuk dilaksanakan tugas. Selepas itu, kami memulakan kumpulan goroutine, dan setiap goroutine memperoleh tugas daripada baris gilir tugas dan melaksanakannya. Akhir sekali, tunggu semua tugasan diselesaikan melalui objek WaitGroup.

3. Ringkasan:

Melalui pelaksanaan kod yang dioptimumkan di atas, kami boleh mengurus tugas serentak dengan lebih baik dan mengelakkan kesesakan prestasi yang disebabkan oleh penggunaan sejumlah besar goroutine dan WaitGroups. Reka bentuk penjadual serentak membolehkan kami mengendalikan tugas serentak dengan lebih cekap dan meningkatkan keupayaan serentak dan prestasi keseluruhan program.

Selain itu, untuk senario konkurensi yang lebih kompleks, kami boleh meningkatkan lagi prestasi dan fleksibiliti penjadual serentak dengan memperkenalkan kumpulan sambungan, keutamaan tugas, strategi penjadualan, dsb. Saya berharap artikel ini dapat memberi pembaca rujukan dan bantuan semasa menulis program serentak yang cekap.

Atas ialah kandungan terperinci Penjadual serentak Golang: pelaksanaan dioptimumkan Go WaitGroup. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!