使用channel流提前预处理部分信息，和普通的线性处理会有巨大的差别吗

package main

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

func main() {
    count, concurrcy := 10, 1

    costs := make([]time.Duration, count)
    cost1s := make([]time.Duration, count)
    for index := 0; index < 10; index++ {
        // directly
        var wg sync.WaitGroup
        wg.Add(concurrcy)
        now := time.Now()
        for index := 0; index < concurrcy; index++ {
            go func() {
                directlyGet()
                doAnother()
                wg.Done()
            }()
        }
        wg.Wait()
        costs[index] = time.Since(now)

        // channel
        var wg1 sync.WaitGroup
        wg1.Add(concurrcy)
        now1 := time.Now()
        for index := 0; index < concurrcy; index++ {
            go func() {
                <-channelGet()
                doAnother()
                wg1.Done()
            }()
        }
        wg1.Wait()
        cost1s[index] = time.Since(now1)
    }

    var cost, cost1 float64
    for index := 0; index < count; index++ {
        cost += costs[index].Seconds()
        cost1 += cost1s[index].Seconds()
    }
    fmt.Println("cost(avg, ms):", cost*1000/float64(count))
    fmt.Println("cost1(avg, ms):", cost1*1000/float64(count))
    fmt.Println("((cost1-cost)/cost)(%):", ((cost1 - cost) / cost))
}

func directlyGet() string {
    doOther()
    return "result"
}

func doOther() {
    time.Sleep(20 * time.Millisecond)
}

func doAnother() {
    time.Sleep(20 * time.Millisecond)
}

func channelGet() <-chan string {
    stream := make(chan string)
    go func() {
        defer close(stream)
        doOther()
        stream <- "result"
    }()

    return stream
}