速度与并发运行无关

知识点掌握了，还需要不断练习才能熟练运用。下面golang学习网给大家带来一个Golang开发实战，手把手教大家学习《速度与并发运行无关》，在实现功能的过程中也带大家重新温习相关知识点，温故而知新，回头看看说不定又有不一样的感悟！

我编写了一段代码，尝试使用并发，但它无助于运行得更快。我该如何改进？

package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"
    "sync"
)

var wg sync.WaitGroup

func checkerr(e error) {

    if e != nil {
        fmt.Println(e)
    }
}

func readFile() {

    file, err := os.Open("data.txt")
    checkerr(err)
    fres, err := os.Create("resdef.txt")
    checkerr(err)

    defer file.Close()
    defer fres.Close()

    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        wg.Add(1)
        go func() {
            words := strings.Fields(scanner.Text())
            shellsort(words)
            writeToFile(fres, words)
            wg.Done()
        }()
        wg.Wait()
    }
}

func shellsort(words []string) {

    for inc := len(words) / 2; inc > 0; inc = (inc + 1) * 5 / 11 {
        for i := inc; i < len(words); i++ {
            j, temp := i, words[i]
            for ; j >= inc && strings.ToLower(words[j-inc]) > strings.ToLower(temp); j -= inc {
                words[j] = words[j-inc]
            }
            words[j] = temp
        }
    }
}

func writeToFile(f *os.File, words []string) {

    datawriter := bufio.NewWriter(f)
    for _, s := range words {
        datawriter.WriteString(s + " ")
    }
    datawriter.WriteString("\n")
    datawriter.Flush()
}

func main() {
    readFile()
}

一切都运行良好，只是执行所有操作所需的时间与没有并发时相同。

正确答案

您必须将 wg.wait() 放在 for 循环之后：

for condition {
        wg.add(1)
        go func() {
            // a concurrent job here
            wg.done()
        }()       
    }
    wg.wait()

注意：工作本身应该具有并发性质。

这是我经过测试的解决方案 - 从输入文件顺序读取，然后执行 n 并发任务，最后顺序写入输出文件订单，请尝试 this：

package main

import (
    "bufio"
    "fmt"
    "log"
    "os"
    "runtime"
    "sort"
    "strings"
    "sync"
)

type sortqueue struct {
    index int
    data  []string
}

func main() {
    n := runtime.numcpu()
    a := make(chan sortqueue, n)
    b := make(chan sortqueue, n)
    var wg sync.waitgroup
    for i := 0; i < n; i++ {
        wg.add(1)
        go parsort(a, b, &wg)
    }
    go func() {
        file, err := os.open("data.txt")
        if err != nil {
            log.fatal(err)
        }
        defer file.close()
        scanner := bufio.newscanner(file)
        i := 0
        for scanner.scan() {
            a <- sortqueue{index: i, data: strings.fields(scanner.text())}
            i++
        }
        close(a)
        err = scanner.err()
        if err != nil {
            log.fatal(err)
        }
    }()

    fres, err := os.create("resdef.txt")
    if err != nil {
        log.fatal(err)
    }
    defer fres.close()
    go func() {
        wg.wait()
        close(b)
    }()
    writetofile(fres, b, n)
}

func writetofile(f *os.file, b chan sortqueue, n int) {
    m := make(map[int][]string, n)
    order := 0
    for v := range b {
        m[v.index] = v.data
        var slice []string
        exist := true
        for exist {
            slice, exist = m[order]
            if exist {
                delete(m, order)
                order++
                s := strings.join(slice, " ")
                fmt.println(s)
                _, err := f.writestring(s + "\n")
                if err != nil {
                    log.fatal(err)
                }
            }
        }
    }
}

func parsort(a, b chan sortqueue, wg *sync.waitgroup) {
    defer wg.done()
    for q := range a {
        sort.slice(q.data, func(i, j int) bool { return q.data[i] < q.data[j] })
        b <- q
    }
}

data.txt 文件：

1 2 0 3

a 1 b d 0 c 

aa cc bb

输出：

0 1 2 3

0 1 a b c d

aa bb cc

今天带大家了解了的相关知识，希望对你有所帮助；关于Golang的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~