goroutine 花费的时间太长

学习知识要善于思考，思考，再思考！今天golang学习网小编就给大家带来《goroutine 花费的时间太长》，以下内容主要包含等知识点，如果你正在学习或准备学习Golang，就都不要错过本文啦~让我们一起来看看吧，能帮助到你就更好了！

我的理解是，对于无缓冲通道（jobs），您需要发送器和接收器，但我的代码顺序有问题，需要很长时间才能完成。

const numWorkers = 5
type workerJob struct {
    FirstID   string
    SecondID string
}

func worker(ctx *gin.Context, fs *firestore.Client, jobs <-chan *workerJob, done chan<- bool) {
    for job := range jobs {
        firstID := job.FirstID
        secondID := job.SecondID
        if err := saveUpdate(ctx, firstID, secondID, fs); err != nil {
            // handle error
        }
    }
    done <- true
}

func UpdateSomething(ctx *gin.Context) {
    fs, err := firestore.NewClient(ctx, "some_ID")
    if err != nil {
        // handle error
    }
    defer fs.Close()

    docsnaps, err := fs.CollectionGroup("someCollection").Where("someCondition", "==", true).Documents(ctx).GetAll()
    if err != nil {
        // handle error
    }
    uniqueSomethings := make(map[string]struct{})
    jobs := make(chan *workerJob)
    done := make(chan bool, numWorkers)
    for w := 1; w <= numWorkers; w++ {
         go worker(ctx, fs, jobs, done)
    }
    for _, docsnap := range docsnaps {
        var someType SomeType
        err := docsnap.DataTo(&someType)
        if err != nil { 
            // handle error
        }
        for _, prop := range someType.prop {
            if strings.Contains(prop.Name, "someString") {
                someID := prop.Name[strings.LastIndex(prop.Name, ":")+1:]
                if _, ok := uniqueSomethings[someID]; !ok {
                    uniqueSomethings[someID] = struct{}{}
                    job := &workerJob{
                        FirstID: dashboard.CustomerID,
                        SecondID:   someID[strings.Index(someID, "_")+1:],
                    }
                    jobs <- job
                }
            }
        }
    }
    close(jobs)
    for i := 1; i <= numWorkers; i++ {
        select {
        case <-done:
        }
    }
    return
}

解决方案

我不完全明白为什么，但我已经能够将时间缩短 6 倍！我决定创建一个作业切片，然后创建一个具有预定义容量（该切片的长度）的通道，然后循环该切片并将作业发送到通道，如下所示：

func UpdateSomething(ctx *gin.Context) {
    fs, err := firestore.NewClient(ctx, "some_ID")
    if err != nil {
        // handle error
    }
    defer fs.Close()

    docsnaps, err := fs.CollectionGroup("someCollection").Where("someCondition", "==", true).Documents(ctx).GetAll()
    if err != nil {
        // handle error
    }
    uniqueSomethings := make(map[string]struct{})
    jobsArr := make([]*workerJob, 0)
   
    for _, docsnap := range docsnaps {
        var someType SomeType
        err := docsnap.DataTo(&someType)
        if err != nil { 
            // handle error
        }
        for _, prop := range someType.prop {
            if strings.Contains(prop.Name, "someString") {
                someID := prop.Name[strings.LastIndex(prop.Name, ":")+1:]
                if _, ok := uniqueSomethings[someID]; !ok {
                    uniqueSomethings[someID] = struct{}{}
                    job := &workerJob{
                        FirstID: dashboard.CustomerID,
                        SecondID:   someID[strings.Index(someID, "_")+1:],
                    }
                    jobsArr = append(jobsArr, job)
                }
            }
        }
    }
    done := make(chan bool, numWorkers)
    jobs := make(chan *workerJob, len(jobsArr))
     
    for w := 1; w <= numWorkers; w++ {
         go worker(ctx, fs, jobs, done)
    }
    for _, job := range jobsArr {
        jobs <- job
    }
    close(jobs)
    for i := 1; i <= numWorkers; i++ {
        select {
        case <-done:
        }
    }
    return
}

本篇关于《goroutine 花费的时间太长》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于Golang的相关知识，请关注golang学习网公众号！