使用Go语言编写并发程序

作者：佚名上传时间：2023-03-23 运行软件：Go语言标准库、Goroutine、channel 软件版本：Go 1.16 版权申诉

Go语言是一门支持并发编程的语言，其中协程是其并发编程的核心概念。在本文中，我们将介绍Go语言中的协程使用方法以及常用的并发编程模式和锁机制。

Go语言协程使用

协程（Goroutine）是Go语言中的轻量级线程，与传统的线程相比，协程的创建和销毁都非常快速，而且占用的资源非常少。

下面是一个简单的协程使用示例：

package main

import (
    "fmt"
    "time"
)

func printNumbers() {
    for i := 0; i < 10; i++ {
        fmt.Printf("%d ", i)
    }
}

func main() {
    go printNumbers()
    time.Sleep(time.Second)
}

在上面的示例中，我们使用go关键字启动了一个新的协程，并在main函数中使用time.Sleep函数等待协程执行完毕。

Go语言并发模式

在并发编程中，有一些常用的模式可以帮助我们更好地组织和管理协程，下面是几个常用的并发模式：

Worker Pool模式

Worker Pool模式使用一组固定数量的协程来处理任务，每个协程都从任务队列中获取任务并执行。这种模式可以有效地控制协程的数量，防止过多的协程占用系统资源。

以下是一个Worker Pool模式的示例：

package main

import (
    "fmt"
    "sync"
)

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Printf("Worker %d started job %d\n", id, j)
        time.Sleep(time.Second)
        fmt.Printf("Worker %d finished job %d\n", id, j)
        results <- j * 2
    }
}

func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)

    // 启动3个协程来处理任务
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    // 发送9个任务到任务队列中
    for j := 1; j <= 9; j++ {
        jobs <- j
    }
    close(jobs)

    // 从结果队列中读取并打印处理结果
    for a := 1; a <= 9; a++ {
        <-results
    }
}

在上面的示例中，我们使用了两个无缓冲通道jobs和results，jobs通道用于存储任务，results通道用于存储处理结果。在main函数中，我们启动了3个协程来处理任务，然后向jobs通道中发送9个任务，最后从results通道中读取并打印处理结果。

Pipeline模式

Pipeline模式是将任务分解成一系列的处理阶段，每个阶段由一个协程来处理。这种模式可以将任务的处理过程变得更加清晰和模块化。

以下是一个Pipeline模式的示例：

package main

import "fmt"

func gen(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        for _, n := range nums {
            out <- n
        }
        close(out)
    }()
    return out
}

func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            out <- n * n
        }
        close(out)
    }()
    return out
}

func main() {
    in := gen(2, 3)
    out := square(in)
    for n := range out {
        fmt.Println(n)
    }
}

在上面的示例中，我们定义了两个协程gen和square，gen协程用于生成输入数据，square协程用于计算输入数据的平方。在main函数中，我们先调用gen协程生成输入数据，然后将其传递给square协程进行处理，并从square协程的输出通道中读取并打印处理结果。

Go语言中的锁机制

在并发编程中，锁机制可以帮助我们确保共享资源的访问不会出现竞态条件。在Go语言中，常用的锁机制有sync.Mutex和sync.RWMutex。

以下是一个使用sync.Mutex的示例：

package main

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

type Counter struct {
    mu    sync.Mutex
    count int
}

func (c *Counter) Incr() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.count++
}

func (c *Counter) Count() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.count
}

func main() {
    var wg sync.WaitGroup
    c := Counter{}
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            c.Incr()
            wg.Done()
        }()
    }
    wg.Wait()
    fmt.Println(c.Count())
}

在上面的示例中，我们定义了一个Counter结构体，其中包含一个互斥锁mu和一个计数器count。在Incr和Count方法中，我们都使用了mu.Lock和mu.Unlock函数来确保并发访问计数器时不会出现竞态条件。

示例代码

以上就是本文中介绍的一些Go并发编程的基本知识和常用模式，下面是完整的示例代码：

// 协程使用示例
package main

import (
    "fmt"
    "time"
)

func printNumbers() {
    for i := 0; i < 10; i++ {
        fmt.Printf("%d ", i)
    }
}

func main() {
    go printNumbers()
    time.Sleep(time.Second)
}

// Worker Pool模式示例
package main

import (
    "fmt"
    "sync"
)

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Printf("Worker %d started job %d\n", id, j)
        time.Sleep(time.Second)
        fmt.Printf("Worker %d finished job %d\n", id, j)
        results <- j * 2
    }
}

func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)

    // 启动3个协程来处理任务
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    // 发送9个任务到任务队列中
    for j := 1; j <= 9; j++ {
        jobs <- j
    }
    close(jobs)

    // 从结果队列中读取并打印处理结果
    for a := 1; a <= 9; a++ {
        <-results
    }
}

// Pipeline模式示例
package main

import "fmt"

func gen(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        for _, n := range nums {
            out <- n
        }
        close(out)
    }()
    return out
}

func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            out <- n * n
        }
        close(out)
    }()
    return out
}

func main() {
    in := gen(2, 3)
    out := square(in)
    for n := range out {
        fmt.Println(n)
    }
}

// 使用sync.Mutex的示例
package main

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

type Counter struct {
    mu    sync.Mutex
    count int
}

func (c *Counter) Incr() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.count++
}

func (c *Counter) Count() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.count
}

func main() {
    var wg sync.WaitGroup
    c := Counter{}
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            c.Incr()
            wg.Done()
        }()
    }
    wg.Wait()
    fmt.Println(c.Count())
}