29、Go 并发编程：线程安全映射与并发数据处理-优快云博客

本文链接：https://blog.youkuaiyun.com/c6d7e8f9g/article/details/155299818

Go 并发编程：线程安全映射与并发数据处理

1. 文件内容处理与并发设计

在处理文件内容时，我们通常会逐行遍历文件。每当找到匹配的行，就会将一个 Result 值发送到结果通道。如果结果通道的缓冲区已满，发送操作将被阻塞。处理的任何文件都可能产生任意数量的结果，如果文件中没有行与正则表达式匹配，则结果数量为零。

在 Go 中处理文本文件时，如果读取行时发生错误，我们会在处理该行后处理该错误。 bufio.Reader.ReadBytes() 方法遇到错误（包括文件结束）时，会返回错误发生前读取的字节以及错误信息。为确保处理最后一行（无论是否以换行符结尾），我们在处理行后处理错误。但这种处理方式存在一个缺点：如果正则表达式可以匹配空字符串，并且我们得到一个非 io.EOF 的非空错误，可能会产生虚假匹配。

为了使程序跨平台工作，我们使用 bytes.TrimRight() 方法去除行末尾的换行符和回车符。另外，我们将行作为字节切片读取，并使用 regexp.Regexp.Match() 方法进行匹配，仅对匹配的行进行从 []byte 到 string 的转换。行号从 1 开始计数，这是常规做法。

并发编程中，一些程序（如 cgrep ）的设计具有很好的特性，其并发框架简单，且与实际处理分离，两者之间的唯一联系是结果通道。这种关注点分离在 Go 并发程序中很常见，与使用低级并发构造（如互斥锁）相比，能避免在整个程序中频繁使用加锁和解锁代码，从而使程序逻辑更清晰。

2. 线程安全映射的实现

Go 的 sync 和 sync/atomic 包提供了创建并发算法和数据结构所需的低级操作。我们也可以使用 Go 的高级通道，确保对现有数据结构（如映射或切片）的所有访问都进行序列化，从而使其线程安全。

下面我们将开发一个线程安全的映射，它具有字符串键和 interface{} 值（即任意值），可以安全地由任意数量的 goroutine 共享，且无需使用锁。

2.1 接口和类型定义

type SafeMap interface {
    Insert(string, interface{})
    Delete(string)
    Find(string) (interface{}, bool)
    Len() int
    Update(string, UpdateFunc)
    Close() map[string]interface{}
}

type UpdateFunc func(interface{}, bool) interface{}

type safeMap chan commandData

type commandData struct {
    action  commandAction
    key     string
    value   interface{}
    result  chan<- interface{}
    data    chan<- map[string]interface{}
    updater UpdateFunc
}

type commandAction int

const (
    remove commandAction = iota
    end
    find
    insert
    length
    update
)

SafeMap 接口定义了安全映射支持的方法， safeMap 是具体类型，基于 chan commandData 实现。 commandData 结构体用于封装操作命令和相关数据。

2.2 方法实现

func (sm safeMap) Insert(key string, value interface{}) {
    sm <- commandData{action: insert, key: key, value: value}
}

func (sm safeMap) Delete(key string) {
    sm <- commandData{action: remove, key: key}
}

type findResult struct {
    value interface{}
    found bool
}

func (sm safeMap) Find(key string) (value interface{}, found bool) {
    reply := make(chan interface{})
    sm <- commandData{action: find, key: key, result: reply}
    result := (<-reply).(findResult)
    return result.value, result.found
}

func (sm safeMap) Len() int {
    reply := make(chan interface{})
    sm <- commandData{action: length, result: reply}
    return (<-reply).(int)
}

func (sm safeMap) Update(key string, updater UpdateFunc) {
    sm <- commandData{action: update, key: key, updater: updater}
}

func (sm safeMap) Close() map[string]interface{} {
    reply := make(chan map[string]interface{})
    sm <- commandData{action: end, data: reply}
    return <-reply
}

这些方法通过向 safeMap 通道发送 commandData 结构体来执行相应的操作。例如， Insert 方法将插入操作的命令数据发送到通道， Find 方法创建一个回复通道，发送查找命令并等待回复。

2.3 创建和运行

func New() SafeMap {
    sm := make(safeMap)
    go sm.run()
    return sm
}

func (sm safeMap) run() {
    store := make(map[string]interface{})
    for command := range sm {
        switch command.action {
        case insert:
            store[command.key] = command.value
        case remove:
            delete(store, command.key)
        case find:
            value, found := store[command.key]
            command.result <- findResult{value, found}
        case length:
            command.result <- len(store)
        case update:
            value, found := store[command.key]
            store[command.key] = command.updater(value, found)
        case end:
            close(sm)
            command.data <- store
        }
    }
}

New 函数创建一个 safeMap 通道，并启动一个 goroutine 执行 run 方法。 run 方法创建一个存储映射，通过循环从通道接收命令，并根据命令类型执行相应操作。

下面是线程安全映射的操作流程 mermaid 图：

graph LR
    A[创建 SafeMap] --> B[发送命令到 safeMap 通道]
    B --> C{命令类型}
    C -->|insert| D[插入键值对到存储映射]
    C -->|remove| E[从存储映射删除键值对]
    C -->|find| F[查找键值对并返回结果]
    C -->|length| G[返回存储映射长度]
    C -->|update| H[更新键值对]
    C -->|end| I[关闭通道并返回存储映射]

3. Apache 报告程序示例

Apache 报告程序的目的是读取 Apache 服务器的 access.log 文件，并输出每个唯一 HTML 页面的访问次数。为了提高处理效率，我们使用多个 goroutine 进行并发处理。

3.1 使用共享线程安全映射同步

apachereport1 程序使用前面开发的安全映射来提供共享的线程安全映射。其并发结构如下：

var workers = runtime.NumCPU()

func main() {
    runtime.GOMAXPROCS(runtime.NumCPU())
    if len(os.Args) != 2 || os.Args[1] == "-h" || os.Args[1] == "--help" {
        fmt.Printf("usage: %s <file.log>\n", filepath.Base(os.Args[0]))
        os.Exit(1)
    }
    lines := make(chan string, workers*4)
    done := make(chan struct{}, workers)
    pageMap := safemap.New()
    go readLines(os.Args[1], lines)
    processLines(done, pageMap, lines)
    waitUntil(done)
    showResults(pageMap)
}

func readLines(filename string, lines chan<- string) {
    file, err := os.Open(filename)
    if err != nil {
        log.Fatal("failed to open the file:", err)
    }
    defer file.Close()
    reader := bufio.NewReader(file)
    for {
        line, err := reader.ReadString('\n')
        if line != "" {
            lines <- line
        }
        if err != nil {
            if err != io.EOF {
                log.Println("failed to finish reading the file:", err)
            }
            break
        }
    }
    close(lines)
}

func processLines(done chan<- struct{}, pageMap safemap.SafeMap, lines <-chan string) {
    getRx := regexp.MustCompile(`GET[ \t]+([^ \t\n]+[.]html?)`)
    incrementer := func(value interface{}, found bool) interface{} {
        if found {
            return value.(int) + 1
        }
        return 1
    }
    for i := 0; i < workers; i++ {
        go func() {
            for line := range lines {
                if matches := getRx.FindStringSubmatch(line); matches != nil {
                    pageMap.Update(matches[1], incrementer)
                }
            }
            done <- struct{}{}
        }()
    }
}

func waitUntil(done <-chan struct{}) {
    for i := 0; i < workers; i++ {
        <-done
    }
}

func showResults(pageMap safemap.SafeMap) {
    pages := pageMap.Close()
    for page, count := range pages {
        fmt.Printf("%8d %s\n", count, page)
    }
}

main 函数初始化通道和安全映射，启动读取和处理 goroutine，等待处理完成并输出结果。 readLines 函数读取文件内容并发送到 lines 通道， processLines 函数创建多个 goroutine 处理行，使用 SafeMap 的 Update 方法更新页面访问计数。

下面是 apachereport1 程序的处理流程 mermaid 图：

graph LR
    A[读取文件] --> B[发送行到 lines 通道]
    B --> C[多个 worker goroutine 从 lines 通道接收行]
    C --> D{匹配 HTML 页面}
    D -->|是| E[使用 SafeMap 更新页面计数]
    D -->|否| C
    E --> F[处理完成发送信号到 done 通道]
    F --> G[主 goroutine 等待所有信号]
    G --> H[关闭 SafeMap 并输出结果]

使用 SafeMap 接口提供了线程安全和简单的语法，但安全映射的值是通用的 interface{} 类型，需要在 incrementer 函数中进行类型断言。

4. 不同同步方式的比较

除了使用线程安全映射，我们还可以使用互斥锁保护的映射或通过合并本地映射来实现同步。

4.1 互斥锁保护的映射

apachereport2 程序使用自定义类型封装映射和互斥锁。

type pageMap struct {
    countForPage map[string]int
    mutex        *sync.RWMutex
}

func NewPageMap() *pageMap {
    return &pageMap{make(map[string]int), new(sync.RWMutex)}
}

func (pm *pageMap) Increment(page string) {
    pm.mutex.Lock()
    defer pm.mutex.Unlock()
    pm.countForPage[page]++
}

func (pm *pageMap) Len() int {
    pm.mutex.RLock()
    defer pm.mutex.RUnlock()
    return len(pm.countForPage)
}

这种方式使用互斥锁确保对映射的访问是线程安全的，但需要在每个修改映射的方法中进行加锁和解锁操作。

4.2 合并本地映射

apachereport3 程序让每个 worker goroutine 拥有自己的本地映射，处理完成后将这些映射合并到一个整体映射中。

func processLines(results chan<- map[string]int, getRx *regexp.Regexp, lines <-chan string) {
    countForPage := make(map[string]int)
    for line := range lines {
        if matches := getRx.FindStringSubmatch(line); matches != nil {
            countForPage[matches[1]]++
        }
    }
    results <- countForPage
}

func merge(results <-chan map[string]int, totalForPage map[string]int) {
    for i := 0; i < workers; i++ {
        countForPage := <-results
        for page, count := range countForPage {
            totalForPage[page] += count
        }
    }
}

这种方式在处理过程中没有竞争，但需要额外的内存存储本地映射，并且合并操作可能成为瓶颈。

下面是不同同步方式的比较表格：
| 同步方式 | 优点 | 缺点 |
| ---- | ---- | ---- |
| 线程安全映射 | 线程安全，语法简单，无需锁 | 值为 interface{} 类型，需类型断言 |
| 互斥锁保护的映射 | 可使用具体数据类型，功能灵活 | 需要在方法中加锁解锁，代码复杂 |
| 合并本地映射 | 处理过程无竞争，吞吐量高 | 需要额外内存，合并可能成为瓶颈 |

综上所述，在并发编程中，我们可以根据具体需求选择合适的同步方式。线程安全映射适用于需要简单线程安全操作的场景；互斥锁保护的映射适用于对性能要求较高且需要具体数据类型的场景；合并本地映射适用于处理过程中竞争较大的场景。

Go 并发编程：线程安全映射与并发数据处理

5. 线程安全映射的使用场景和注意事项

线程安全映射在很多并发编程场景中都有应用，比如多个 goroutine 需要同时读写一个共享映射时，使用线程安全映射可以避免数据竞争问题。但在使用时也有一些注意事项：

死锁问题 ：在使用 Update 方法时，如果传入的 updater 函数调用了 SafeMap 的其他方法，会导致死锁。因为 Update 操作需要等待 updater 函数返回才能完成，而 updater 函数调用的 SafeMap 方法又会等待 Update 操作完成，从而形成死锁。
性能开销 ：与普通映射相比，线程安全映射有一定的性能开销。每个命令都需要创建 commandData 结构体并通过通道发送，这会增加额外的开销。因此，在对性能要求极高的场景下，需要谨慎使用。

6. 不同同步方式的性能分析

为了更直观地了解不同同步方式的性能差异，我们可以进行一些简单的性能测试。假设我们有一个场景，多个 goroutine 需要对一个映射进行大量的读写操作。

以下是一个简单的性能测试代码示例：

package main

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

// 线程安全映射
type SafeMap chan commandData

type commandData struct {
    action  commandAction
    key     string
    value   interface{}
    result  chan<- interface{}
    data    chan<- map[string]interface{}
    updater func(interface{}, bool) interface{}
}

type commandAction int

const (
    insert commandAction = iota
    find
)

func (sm SafeMap) Insert(key string, value interface{}) {
    sm <- commandData{action: insert, key: key, value: value}
}

func (sm SafeMap) Find(key string) (interface{}, bool) {
    reply := make(chan interface{})
    sm <- commandData{action: find, key: key, result: reply}
    result := (<-reply).(struct {
        value interface{}
        found bool
    })
    return result.value, result.found
}

func NewSafeMap() SafeMap {
    sm := make(SafeMap)
    go func() {
        store := make(map[string]interface{})
        for command := range sm {
            switch command.action {
            case insert:
                store[command.key] = command.value
            case find:
                value, found := store[command.key]
                command.result <- struct {
                    value interface{}
                    found bool
                }{value, found}
            }
        }
    }()
    return sm
}

// 互斥锁保护的映射
type MutexMap struct {
    data map[string]interface{}
    mutex sync.Mutex
}

func (mm *MutexMap) Insert(key string, value interface{}) {
    mm.mutex.Lock()
    defer mm.mutex.Unlock()
    mm.data[key] = value
}

func (mm *MutexMap) Find(key string) (interface{}, bool) {
    mm.mutex.Lock()
    defer mm.mutex.Unlock()
    value, found := mm.data[key]
    return value, found
}

func NewMutexMap() *MutexMap {
    return &MutexMap{
        data: make(map[string]interface{}),
    }
}

func testSafeMap() {
    sm := NewSafeMap()
    var wg sync.WaitGroup
    start := time.Now()
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            key := fmt.Sprintf("key-%d", id)
            sm.Insert(key, id)
            _, _ = sm.Find(key)
        }(i)
    }
    wg.Wait()
    elapsed := time.Since(start)
    fmt.Printf("SafeMap elapsed: %s\n", elapsed)
}

func testMutexMap() {
    mm := NewMutexMap()
    var wg sync.WaitGroup
    start := time.Now()
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            key := fmt.Sprintf("key-%d", id)
            mm.Insert(key, id)
            _, _ = mm.Find(key)
        }(i)
    }
    wg.Wait()
    elapsed := time.Since(start)
    fmt.Printf("MutexMap elapsed: %s\n", elapsed)
}

func main() {
    testSafeMap()
    testMutexMap()
}

通过运行上述代码，我们可以得到线程安全映射和互斥锁保护的映射在相同操作下的执行时间，从而对比它们的性能。

7. 并发编程中的最佳实践

在并发编程中，为了提高程序的性能和稳定性，我们可以遵循以下最佳实践：

合理使用通道 ：通道是 Go 语言中实现并发同步的重要工具。使用通道可以避免使用低级的并发构造（如互斥锁），使代码更加简洁和易于维护。例如，在 apachereport 程序中，使用通道来组织数据的传输和处理，避免了数据竞争问题。
分离关注点 ：将并发框架和实际处理逻辑分离，使代码的结构更加清晰。如线程安全映射的实现，将通道操作和映射的实际读写操作分离，降低了代码的复杂度。
避免死锁 ：在编写并发代码时，要特别注意避免死锁问题。如前面提到的线程安全映射的 Update 方法，要确保 updater 函数不会调用 SafeMap 的其他方法。

8. 总结与展望

Go 语言的并发编程特性为我们提供了强大的工具来处理并发任务。线程安全映射、互斥锁保护的映射和合并本地映射等同步方式各有优缺点，我们可以根据具体的应用场景选择合适的同步方式。

在未来的并发编程中，随着硬件性能的提升和应用场景的不断复杂化，我们可能会面临更多的挑战。例如，如何在大规模并发的情况下提高程序的性能和可扩展性。我们可以进一步研究和探索新的并发算法和数据结构，以满足不断增长的需求。

以下是一个总结不同同步方式的 mermaid 流程图：

graph LR
    A[并发编程同步方式] --> B[线程安全映射]
    A --> C[互斥锁保护的映射]
    A --> D[合并本地映射]
    B --> E[优点: 线程安全, 语法简单]
    B --> F[缺点: 值为 interface{}, 需类型断言]
    C --> G[优点: 可使用具体数据类型, 功能灵活]
    C --> H[缺点: 需要加锁解锁, 代码复杂]
    D --> I[优点: 处理无竞争, 吞吐量高]
    D --> J[缺点: 需要额外内存, 合并可能成瓶颈]

总之，掌握并发编程的技巧和同步方式的选择，对于开发高效、稳定的 Go 程序至关重要。我们应该不断学习和实践，提高自己的并发编程能力。