掌握Go语言：Go 并发编程，轻松应对大规模任务处理和高并发请求（34）

并发是 Go 语言的一个重要特性，通过 goroutine 和 channel，Go 提供了简单而强大的并发编程模型。goroutine 是轻量级的线程，可以在程序中并发执行任务，而 channel 则是用于 goroutine 之间的通信的管道。

Go 并发应用场景

1. 并行计算

应用场景：在需要处理大量计算密集型任务时，可以使用并发来提高计算速度。

示例：

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    numTasks := 10

    for i := 0; i < numTasks; i++ {
        wg.Add(1)
        go func(taskID int) {
            defer wg.Done()
            result := doHeavyCalculation(taskID)
            fmt.Println("Task", taskID, "Result:", result)
        }(i)
    }

    wg.Wait()
}

func doHeavyCalculation(taskID int) int {
    // 模拟耗时计算
    return taskID * 2
}

2. 并发请求处理

应用场景：在网络服务中，需要处理大量的并发请求，可以使用并发来提高请求处理能力。

示例：

package main

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
}

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, %s!", r.URL.Path[1:])
}

3. 数据流处理

应用场景：在数据处理任务中，需要对数据进行并发处理和传递。

示例：

package main

import "fmt"

func main() {
    dataStream := make(chan int)
    resultStream := make(chan int)

    go produceData(dataStream)
    go processData(dataStream, resultStream)
    go consumeData(resultStream)

    // 等待数据处理完成
    var input string
    fmt.Scanln(&input)
}

func produceData(out chan<- int) {
    for i := 0; i < 10; i++ {
        out <- i
    }
    close(out)
}

func processData(in <-chan int, out chan<- int) {
    for data := range in {
        out <- data * 2
    }
    close(out)
}

func consumeData(in <-chan int) {
    for result := range in {
        fmt.Println("Processed result:", result)
    }
}

Go 并发注意事项

1. 避免竞态条件

注意事项：并发执行的 goroutine 可能会访问和修改共享数据，需要避免出现竞态条件，即多个 goroutine 同时修改同一份数据导致结果不确定。

示例：

package main

import (
    "fmt"
    "sync"
)

func main() {
    var counter int
    var wg sync.WaitGroup
    numWorkers := 10

    for i := 0; i < numWorkers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            // 临界区操作
            counter++
        }()
    }

    wg.Wait()
    fmt.Println("Counter:", counter)
}

2. 使用互斥锁

注意事项：在处理共享数据时，可以使用互斥锁来保护临界区，确保同一时间只有一个 goroutine 可以访问共享数据。

示例：

package main

import (
    "fmt"
    "sync"
)

func main() {
    var counter int
    var mu sync.Mutex
    var wg sync.WaitGroup
    numWorkers := 10

    for i := 0; i < numWorkers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            // 加锁保护临界区操作
            mu.Lock()
            counter++
            mu.Unlock()
        }()
    }

    wg.Wait()
    fmt.Println("Counter:", counter)
}

总结

Go 语言通过 goroutine 和 channel 提供了简单而强大的并发编程模型，使得并发编程变得容易且高效。在应用中，可以利用并发来提高计算性能、处理并发请求、进行数据流处理等。同时，需要注意避免竞态条件，保护共享数据的一致性，合理使用互斥锁等并发控制机制。