GO语言并发编程

最新推荐文章于 2024-05-17 10:04:07 发布

是阿尘呀

最新推荐文章于 2024-05-17 10:04:07 发布

阅读量728

点赞数 28

分类专栏： golang 文章标签： golang 算法开发语言后端

本文链接：https://blog.csdn.net/m0_72418211/article/details/136549953

版权

golang 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

点击名片关注阿尘blog，一起学习，一起成长

1 Goroutine和channel

Go语言通过goroutine和channel来实现并发编程。Goroutine是Go语言中轻量级的线程，它由Go运行时（runtime）管理，并且拥有自己的栈空间。Goroutine的调度由Go运行时自动完成，不需要程序员手动创建和管理线程。

Channel是Go语言中用于在goroutine之间进行通信的机制，它类似于管道，用于在不同的goroutine之间传递数据。

下面是一个简单的Go语言并发编程案例，使用goroutine和channel实现两个goroutine之间的数据传递：

package main

import (
    "fmt"
    "time"
)

// 生产者函数，向channel中发送数据
func producer(ch chan<- int) {
    for i := 0; i < 5; i++ {
        fmt.Printf("Producer produced: %d\n", i)
        ch <- i // 发送数据到channel
        time.Sleep(time.Second) // 假设每次生产需要一些时间
    }
    close(ch) // 生产完毕后关闭channel
}

// 消费者函数，从channel中接收数据
func consumer(ch <-chan int) {
    for value := range ch { // 从channel中接收数据，直到channel被关闭
        fmt.Printf("Consumer consumed: %d\n", value)
        time.Sleep(time.Second) // 假设每次消费需要一些时间
    }
    fmt.Println("Consumer finished.")
}

func main() {
    ch := make(chan int) // 创建一个int类型的channel

    // 启动生产者goroutine
    go producer(ch)

    // 启动消费者goroutine
    go consumer(ch)

    // 主函数等待足够长的时间，以便观察并发执行的结果
    // 注意：在实际应用中，主函数通常不需要等待，除非有特定的同步需求
    time.Sleep(10 * time.Second)
}

注意事项：

不要传递nil的channel：尝试向nil的channel发送数据或从中接收数据都会导致panic。

关闭channel：一旦你不再需要向channel发送数据，就应该关闭它。接收方可以通过检查第二个返回值来判断channel是否关闭。如果channel已关闭并且没有更多的数据可以接收，则第二个返回值将为false。

避免死锁：确保所有的goroutine最终都能结束，避免产生死锁。这可能意味着你需要确保所有的goroutine都有退出的条件，或者使用sync.WaitGroup等待所有goroutine完成。

不要假设goroutine的执行顺序：goroutine的执行是由Go运行时调度的，因此你不能假设它们的执行顺序。

避免竞态条件：并发编程中常见的错误是竞态条件，即多个goroutine同时访问共享资源时可能导致数据不一致。使用互斥锁（sync.Mutex）或其他同步原语来保护共享资源。

注意性能：虽然goroutine轻量级，但创建大量的goroutine仍然可能对性能产生影响。合理地管理goroutine的数量和生命周期是很重要的。

使用select来处理多个channel：select语句允许你等待多个channel的操作。这对于实现超时、取消操作或同步多个goroutine之间的通信非常有用。

不要阻塞主goroutine：主goroutine（main函数）的结束会导致整个程序的结束。确保主goroutine不会无限制地等待其他goroutine，除非这是你的意图。

2 并发模式

工作者池（Worker Pool）

定义：工作者池是一种并发模式，它创建了一个固定大小的Goroutine池来执行任务。当任务到达时，它会被分配给池中的一个空闲Goroutine。如果所有Goroutine都在工作，任务会被排队等待。

作用：工作者池能够限制并发Goroutine的数量，避免因为创建过多的Goroutine而耗尽系统资源。

使用场景：适用于需要处理大量并发任务，但又不希望无限制地增加Goroutine数量的场景。

示例代码：

package main

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

func worker(id int, jobs <-chan int, results chan<- int, wg *sync.WaitGroup) {
    defer wg.Done()
    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() {
    numJobs := 10
    numWorkers := 3
    jobs := make(chan int, numJobs)
    results := make(chan int, numJobs)
    var wg sync.WaitGroup

    // 启动工作者
    for w := 1; w <= numWorkers; w++ {
        wg.Add(1)
        go worker(w, jobs, results, &wg)
    }

    // 分配任务
    for j := 1; j <= numJobs; j++ {
        jobs <- j
    }
    close(jobs) // 关闭jobs通道，表示不再发送新任务

    // 收集结果
    for a := 1; a <= numJobs; a++ {
        <-results
    }

    wg.Wait() // 等待所有工作者完成
}

生产者-消费者模型（Producer-Consumer）

定义：生产者-消费者模型是一种并发设计模式，其中生产者负责生成数据并将其放入共享缓冲区，而消费者则从缓冲区中取出数据并处理它。

作用：这种模型可以解耦生产数据和消费数据的速率，使得生产者和消费者可以独立运行，提高系统的吞吐量和响应能力。

使用场景：适用于生产者和消费者速率不匹配的场景，如I/O密集型任务、计算密集型任务等。

示例在前面已提到。

流水线模型（Pipeline）

定义：流水线模型是一种并发设计模式，它将一个大的任务分解成多个阶段，每个阶段由一个或多个Goroutine处理。每个阶段的输出作为下一个阶段的输入，形成一个流水线。

作用：流水线模型可以提高任务的处理效率，通过将大任务拆分成多个小任务并并行处理，可以充分利用多核CPU的优势。

使用场景：适用于需要将一个复杂任务拆分成多个简单任务并行处理的场景，如图像处理、数据转换等。

示例代码：

package main

import (
    "fmt"
    "sync"
)

func main() {
    const numStages = 3
    const numJobs = 5

    // 创建阶段之间的通道
    channels := make([]chan int, numStages)
    for i := range channels {
        channels[i] = make(chan int)
    }

    // 最后的阶段不需要输出通道
    var wg sync.WaitGroup
    wg.Add(numStages)

    // 启动每个阶段的Goroutine
    for i := 0; i < numStages; i++ {
        stage := i
        go func() {
            defer wg.Done()
            for j := 1; j <= numJobs; j++ {
                // 等待上一个阶段的输入
                input := <-channels[stage]
                // 处理输入并输出到下一个阶段
                output := process(input, stage)
                if stage == numStages-1 { // 如果是最后一个阶段，打印结果
                    fmt.Printf("Stage %d: %d\n", stage, output)
                } else {
                    channels[stage+1] <- output // 将输出发送到下一个阶段的通道
                }
            }
        }()
    }

    // 向第一个阶段的通道发送任务
    for j := 1; j <= numJobs; j++ {
        channels[0] <- j
    }
    close(channels[0]) // 关闭第一个阶段的通道，表示不再发送新任务

    // 等待所有阶段完成
    wg.Wait()

    // 关闭剩余的通道
    for i := 1; i < numStages; i++ {
        close(channels[i])
    }
}

// process模拟每个阶段对输入的处理
func process(input, stage int) int {
    return input * (stage + 1)
}

这些并发模式在Go语言中都有广泛的应用，它们能够帮助开发者构建高效、可扩展的并发应用。通过选择适合的模式，开发者可以更加灵活地处理并发问题，提高程序的性能和响应能力

3 同步与互斥

在Go语言中，同步和互斥是确保多个Goroutines之间正确协作和避免数据竞争的关键机制。同步是协调Goroutines之间操作顺序的过程，而互斥则是确保在任意时刻只有一个Goroutine可以访问共享资源。

同步

定义：同步是协调多个Goroutines的执行顺序，确保它们按照预期的方式执行。

关键技术：

Channels：用于Goroutines之间的通信和同步。 WaitGroup：用于等待一组Goroutines的完成。

代码示例：使用Channels进行同步

package main

import "fmt"

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Println("Worker", id, "started job", j)
        // 模拟工作
        for i := 0; i < 100000000; i++ {
        }
        fmt.Println("Worker", id, "finished job", j)
        results <- j * 2
    }
}

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

    // 启动多个worker
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    // 发送任务到jobs通道
    for j := 1; j <= numJobs; j++ {
        jobs <- j
    }
    close(jobs)

    // 从results通道接收结果并打印
    for a := 1; a <= numJobs; a++ {
        <-results
    }
}

作用：确保Goroutines按照预期的顺序执行任务，避免数据竞争。

注意事项：

不要在多个Goroutines之间直接共享内存，除非有适当的同步机制。确保在不再发送数据到通道时关闭它，以便接收方知道何时结束循环。 2. 互斥

定义：互斥是确保在任意时刻只有一个Goroutine可以访问共享资源，以防止数据竞争(竞态条件）。

关键技术：

Mutex：用于保护共享资源不被多个Goroutines同时访问。

代码示例：使用Mutex进行互斥

package main

import (
    "fmt"
    "sync"
)

var (
    counter int
    mutex   sync.Mutex
)

func increment() {
    mutex.Lock()         // 在修改counter之前加锁
    counter++
    mutex.Unlock()       // 释放锁
}

func main() {
    var wg sync.WaitGroup

    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            increment()
        }()
    }

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

作用：确保在多个Goroutines访问共享资源时不会发生数据竞争，保证数据的一致性。

注意事项：

锁应该尽快释放，避免死锁。避免在持有锁的情况下进行阻塞操作，如IO操作。使用defer来确保锁总是被释放，即使在函数中出现错误或提前返回。

在Go中，使用Channels进行同步通常是首选方法，因为它们不仅用于同步，还可以用于Goroutines之间的通信。然而，在某些情况下，当需要更细粒度的控制或保护复杂的数据结构时，Mutexes可能是必要的。

4 内存管理

Go语言在内存管理方面有着出色的设计，这主要得益于它的垃圾回收机制、栈内存分配以及并发模型。在Go中，内存管理主要关注两个方面：如何分配和释放内存，以及如何安全地在并发环境中操作内存。

4.1 Go语言的内存机制

垃圾回收：Go语言使用垃圾回收器自动管理堆内存。当不再有任何变量引用某个对象时，垃圾回收器会自动回收其占用的内存。这避免了手动内存管理的复杂性和潜在的内存泄露问题。

栈内存分配：Go语言中的局部变量和函数调用的参数通常存储在栈内存中。栈内存的分配和释放由编译器自动管理，且效率非常高。当函数执行完成后，栈上的内存会被自动回收。

逃逸分析：编译器会分析代码以确定哪些变量应该分配在堆上（逃逸到堆），哪些变量应该保持在栈上。这有助于优化内存使用。

4.2 并发编程中的内存管理

并发编程中字面内存泄漏和有效管理内存是非常重要的，特别是

在Go语言中，避免内存泄漏和有效管理内存是非常重要的，特别是在处理大数据和长时间运行的项目时。以下是一些关于如何在Go语言中管理内存以避免内存泄漏的建议：

理解Go的垃圾回收器：Go语言使用了一个自动的垃圾回收器来自动回收不再使用的内存。了解垃圾回收器的工作原理和如何调整其性能可以帮助你更有效地管理内存。

避免全局变量和长生命周期的对象：全局变量和长生命周期的对象可能会导致内存占用持续增长。尽量将变量的作用域限制在需要的地方，避免不必要的全局变量。

package main

import (
    "fmt"
)

// 避免使用全局变量，而是传递必要的值作为函数参数
func processData(data []int) {
    // 在函数内部处理数据，而不是使用全局变量
    result := make([]int, len(data))
    for i, v := range data {
        result[i] = v * 2
    }
    fmt.Println(result)
}

func main() {
    data := []int{1, 2, 3, 4, 5}
    processData(data) // 传递数据到函数，而不是使用全局变量
}

使用指针和切片：在Go语言中，指针和切片是管理内存的有效工具。使用指针可以避免不必要的内存分配和复制，而切片则提供了动态数组的功能，可以根据需要增长和缩小。

package main

import (
    "fmt"
)

// 使用指针来避免不必要的内存分配和复制
func modifySlice(s *[]int) {
    // 直接修改传入的切片，而不是创建一个新的切片
    for i := range *s {
        (*s)[i] *= 2
    }
}

func main() {
    data := []int{1, 2, 3, 4, 5}
    modifySlice(&data) // 传递切片的指针，以在函数内部修改它
    fmt.Println(data) // 输出修改后的切片
}

使用defer来清理资源：defer语句用于在函数返回前执行一些清理工作，例如关闭文件、释放锁或数据库连接等。使用defer可以确保资源在不再需要时被正确释放，避免内存泄漏。

package main

import (
    "fmt"
    "os"
)

func main() {
    file, err := os.Open("example.txt")
    if err != nil {
        fmt.Println("Error opening file:", err)
        return
    }
    defer file.Close() // 使用 defer 确保文件被关闭

    // 对文件进行操作...
    fmt.Println("File opened successfully")
}

避免循环引用：循环引用是指两个或多个对象相互引用，导致它们无法被垃圾回收器回收。要避免这种情况，可以使用弱引用或确保在不再需要对象时解除引用关系。

package main

import "fmt"

type A struct {
    B *B
}

type B struct {
    A *A
}

func main() {
    // 创建循环引用
    a := &A{}
    b := &B{A: a}
    a.B = b

    // 手动解除循环引用，以避免内存泄漏
    a.B = nil
    b.A = nil

    // 假设我们不再需要 a和b，现在它们可以被垃圾回收器回收了
}

使用sync.Pool进行对象重用：sync.Pool是一个用于缓存和重用临时对象的池。在高并发的场景下，使用sync.Pool可以避免频繁的内存分配和垃圾回收，提高性能。

package main

import (
    "fmt"
    "sync"
)

func main() {
    var pool = &sync.Pool{
        New: func() interface{} {
            return make([]int, 0, 5) // 初始化一个新的切片
        },
    }

    for i := 0; i < 10; i++ {
        s := pool.Get().([]int) // 从池中获取切片
        s = append(s, i)         // 使用切片
        pool.Put(s)              // 将切片放回池中，以便重用
    }

    // 注意：在实际使用中，将对象放回池中之前，需要确保对象处于可以被安全重用的状态
}

监控和分析内存使用：使用工具如pprof来监控和分析你的程序的内存使用情况。这可以帮助你找到潜在的内存泄漏点，并进行优化。

以上建议，可以在Go语言中有效地管理内存，避免内存泄漏，并提高程序的性能和稳定性。

5 错误和处理

在Go语言中，错误处理和恢复是编程中非常重要的一部分，特别是在并发编程中。在Go中，错误通常通过返回值传递，而不是通过异常抛出。然而，Go也提供了panic和recover机制来处理严重的错误或异常情况。

首先，让我们讨论如何在Goroutine中处理错误。

Goroutine中的错误处理

在Goroutine中处理错误的基本策略是将错误返回给调用者。由于Goroutine是并发执行的，它们通常不会直接“抛出”错误到它们之外的上下文中。相反，它们应该通过通道（channel）将错误发送回主程序或其他协程以进行处理。

以下是一个示例，展示了如何在Goroutine中处理错误，并通过通道将错误发送回主程序：

package main

import (
    "fmt"
    "time"
)

func doWork(errChan chan<- error, id int) {
    // 模拟工作，可能会产生错误
    if id%2 == 0 {
        fmt.Printf("Goroutine %d is working normally\n", id)
    } else {
        err := fmt.Errorf("Goroutine %d encountered an error", id)
        // 将错误发送到通道
        errChan <- err
    }
}

func main() {
    // 创建一个用于接收错误的通道
    errChan := make(chan error)

    // 启动几个Goroutine
    for i := 0; i < 5; i++ {
        go doWork(errChan, i)
    }

    // 等待所有Goroutine完成
    time.Sleep(1 * time.Second)

    // 关闭错误通道
    close(errChan)

    // 遍历错误通道，处理错误
    for err := range errChan {
        if err != nil {
            fmt.Println("Error:", err)
        }
    }
}

在这个例子中，doWork函数模拟了一个可能会产生错误的操作。如果发生错误，它会将错误发送到errChan通道。在main函数中，我们等待了一段时间以让Goroutines有时间执行，然后遍历errChan通道来处理任何收到的错误。

使用defer, panic和recover

panic和recover是Go中用于处理严重错误或异常情况的机制。panic用于引发一个非正常的程序流程中断，而recover用于捕获并处理panic。defer语句用于确保无论函数如何退出，都会执行某些清理操作。

以下是一个使用defer, panic和recover的例子：

package main

import "fmt"

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered in main", r)
        }
    }()

    doWork()
}

func doWork() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered in doWork", r)
        }
    }()

    fmt.Println("Starting doWork")
    panic("Something went wrong!")
    fmt.Println("Ending doWork") // 这行代码不会执行，因为panic发生了
}

在这个例子中，doWork函数中的panic调用会导致程序流程中断，并跳转到最近的defer语句。defer中的recover调用捕获了panic的值，并打印了一条恢复消息。由于doWork函数中的panic，所以紧随其后的fmt.Println("Ending doWork")不会执行。

注意，通常应该避免在常规错误处理中使用panic和recover，因为它们是为处理真正的程序错误和异常情况而设计的。在正常的错误处理中，应该优先使用错误返回值和错误处理模式。

6 性能优化建议

在Go语言中，通过并发来优化和提高程序的性能。以下是一些在Go语言中优化并发编程性能的建议：

1、使用Goroutines： Goroutines是Go语言中的轻量级线程，它们由Go运行时管理，并且非常便宜，可以创建成千上万个而不会给操作系统带来太大的负担。可尽量利用它们来处理并发任务。

2、避免阻塞：阻塞操作（如I/O操作）会阻止goroutine继续执行，直到阻塞操作完成。你应该尽量减少阻塞操作，或者至少让它们不会阻塞整个程序。

// 使用带缓冲的channel来避免阻塞
ch := make(chan Item, bufferSize)
go func() {
    for item := range items {
        ch <- item
    }
    close(ch)
}()

for item := range ch {
    processItem(item)
}

3、使用WaitGroup等待Goroutines完成：当你启动多个goroutines并且需要等待它们全部完成时，使用sync.WaitGroup来同步。

4、选择合适的Channel大小：带缓冲的channel可以缓解goroutines之间的同步压力，但过大的缓冲可能会隐藏程序中的逻辑错误。选择合适的缓冲区大小很重要。

5、避免过度创建Goroutines：虽然goroutines是轻量级的，但过度创建它们也可能导致性能下降。使用工作池（worker pool）模式限制同时运行的goroutine数量。

6、使用Select避免阻塞： select语句允许goroutine等待多个channel操作，从而避免不必要的阻塞。

ch1 := make(chan Item)
ch2 := make(chan Item)

go func() {
    // 生产者
    for item := range items {
        ch1 <- item
    }
    close(ch1)
}()

go func() {
    // 另一个生产者
    for item := range otherItems {
        ch2 <- item
    }
    close(ch2)
}()

for {
    select {
    case item1 := <-ch1:
        processItem(item1)
    case item2 := <-ch2:
        processOtherItem(item2)
    case <-time.After(timeout):
        // 超时处理
        return
    }
}

7、利用Goroutine本地存储：使用sync.Local为goroutine提供本地存储，以减少在goroutine间传递数据的开销。

package main

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

// 定义一个局部存储的键类型
type localKey int

// 定义两个键
var key1 localKey = 1
var key2 localKey = 2

func main() {
    // 创建一个Local对象
    localStore := sync.Local{}

    // 启动两个goroutine
    for i := 0; i < 2; i++ {
        go func(id int) {
            // 在每个goroutine中存储一个值
            localStore.Store(key1, id)

            // 模拟一些工作
            time.Sleep(time.Second)

            // 从localStore中检索值
            if value, ok := localStore.Load(key1); ok {
                fmt.Printf("Goroutine %d retrieved value: %v\n", id, value)
            }

            // 清除存储的值
            localStore.Delete(key1)
        }(i)
    }

    // 等待goroutine完成
    time.Sleep(2 * time.Second)

    // 输出所有goroutine完成后的localStore状态
    fmt.Println("Local store after goroutines finished:", localStore)
}

8、避免不必要的内存分配：在并发程序中，内存分配和垃圾回收可能会成为性能瓶颈。尽量重用对象，避免频繁的内存分配。

9、使用性能分析工具：使用Go的性能分析工具（如pprof）来识别程序的瓶颈，并针对性地进行优化。

10、考虑使用并发安全的数据结构： Go标准库提供了一些并发安全的数据结构，如sync.Map，sync.Pool等，这些数据结构在并发环境下无需额外的锁操作，可以提高性能。

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    var sm sync.Map

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            sm.Store(fmt.Sprintf("counter-%d", id), 0)
            sm.Store(fmt.Sprintf("counter-%d", id), sm.LoadOrDefault(fmt.Sprintf("counter-%d", id), 0)+1)
        }(i)
    }

    wg.Wait()
    sm.Range(func(key, value interface{}) bool {
        fmt.Printf("%v: %v\n", key, value)
        return true
    })
}

记住，并发编程并不总是带来性能提升。在决定使用并发之前，首先要确定程序的瓶颈在哪里，并确保并发是解决这些瓶颈的有效方式。同时，不要过度优化，否则可能会引入额外的复杂性和维护成本。

7 高级特性：Context包

Context包：Context包是Go语言中用于管理Goroutine生命周期和取消操作的机制。通过Context，我们可以传递请求范围的值、取消信号和截止时间等信息，以便在并发操作中实现更加精细的控制。Context包在构建分布式系统、Web服务或长时间运行的后台任务时特别有用，它可以帮助我们避免资源泄漏和Goroutine泄漏等问题。

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    // 创建一个带有超时功能的Context
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    defer cancel() // 确保函数返回前调用cancel，避免资源泄漏

    go func() {
        // 模拟一个长时间运行的任务
        for {
            select {
            case <-ctx.Done():
                // 当Context被取消时，执行这里的代码
                fmt.Println("Task canceled")
                return
            default:
                // 继续执行任务逻辑
                fmt.Println("Task running...")
                time.Sleep(1 * time.Second)
            }
        }
    }()

    // 等待一段时间，然后取消Context
    time.Sleep(3 * time.Second)
    cancel()

    // 等待一段时间以确保Goroutine有时间响应取消信号
    time.Sleep(1 * time.Second)
}

在这个示例中，我们创建了一个带有2秒超时的Context对象。然后，我们启动了一个Goroutine来模拟一个长时间运行的任务。在这个Goroutine中，我们使用select语句来监听Context的Done()通道。当Context被取消时（例如，超时到达或显式调用cancel函数），Done()通道会关闭，并且Goroutine会收到通知并退出。主函数中等待一段时间后调用cancel()函数来取消Context，从而触发Goroutine的退出。

除了Context还有select以及sync.Map等等已在前面提到不在赘述，更多特性欢迎大家一起交流讨论。

扫描二维码关注阿尘blog，一起交流学习

是阿尘呀

关注

28
点赞
踩
11

收藏

觉得还不错? 一键收藏
打赏
0
评论
GO语言并发编程

点击名片关注阿尘blog，一起学习，一起成长1 Goroutine和channelGo语言通过goroutine和channel来实现并发编程。Goroutine是Go语言中轻量级的线程，它由Go运行时（runtime）管理，并且拥有自己的栈空间。Goroutine的调度由Go运行时自动完成，不需要程序员手动创建和管理线程。Channel是Go语言中用于在goroutine之间进行通信的机制，它...
复制链接

扫一扫