golang并发与并行

岳伟同志
233 阅读4分钟

1、如何在 Go 中实现并发安全？

在Go语言中确保并发编程的安全性可以通过以下几种方法来实现：

  1. 使用通道（channel）：Go语言的并发模型主要通过通道来实现，通道是一种用来在多个goroutine之间传递数据的管道。使用通道可以避免竞争条件，确保并发操作的安全性。
  2. 使用互斥锁（mutex）：在Go语言中可以使用sync包中的互斥锁来保护共享资源，确保在同一时刻只有一个goroutine访问共享资源。互斥锁可以通过Lock()和Unlock()方法来实现对共享资源的同步访问。
  3. 使用原子操作：Go语言提供了atomic包来实现原子操作，可以确保对共享资源的原子性操作，避免竞争条件。
  4. 使用WaitGroup：WaitGroup可以用来等待一组goroutine的结束，确保所有goroutine执行完毕后再继续执行后续操作。
  5. 使用并发安全的数据结构：Go语言中提供了一些并发安全的数据结构，如sync.Map、sync.Pool等，可以避免在并发操作中出现竞争条件。

通过以上方法的结合使用，可以确保Go语言并发编程的安全性，避免出现数据竞争和其他并发问题。

2、描述 Go 的并发模型，Goroutine 是如何工作的？

Go 语言的并发模型是基于通道（channel）的。Go 程序中的函数可以并发运行，这归功于goroutine。goroutine 是一种轻量级的线程，由 Go 语言的 run 函数实现。每个 goroutine 都有一个唯一的 ID，用于标识自身。Go 语言运行时管理着所有的 goroutine，它们在运行时可以并发运行。

Goroutine 的工作原理如下：

  1. 当一个函数被调用时，它会被存储在一个调用栈中。

  2. 当函数遇到一个包含 goroutine 关键字的关键字时，它会在当前栈上创建一个新的 goroutine。

  3. 新的 goroutine 的 ID 会被返回给调用者，以便在未来的时间点恢复该 goroutine。

  4. 当新创建的 goroutine 开始运行时，它会在一个新的栈上运行，独立于原始函数的栈。

  5. 在一个 goroutine 中，您可以调用其他 goroutine 的函数，只需通过 channel 传递参数和返回值。

  6. 当一个 goroutine 完成时，它会在其所在的栈上弹出，并返回到调用者。

  7. 您可以使用 channel 来控制 goroutine 的行为，例如等待、发送和接收数据。

package main

import (
    "fmt"
    "time"
)

func main() {
    start := time.Now()

    ch := make(chan int)
    go func() {
        ch <- func() {
            fmt.Println("Calculating:", 2 * 3)
        }()
    }()
    go func() {
        ch <- func() {
            fmt.Println("Calculating:", 4 * 5)
        }()
    }()
    for i := 0; i < 2; i++ {
        <-ch
    }
    elapsed := time.Since(start)
    
    fmt.Println("Total time:", elapsed)
}

在这个示例中，我们创建了一个包含两个 goroutine 的 main 函数。每个 goroutine 计算 2x3 和 4x5 的结果，并将结果发送回 main 函数。由于 goroutine 可以并发运行，因此两个计算可以同时进行，从而减少总的运行时间。

3、解释 Go 中的死锁，并提供如何避免死锁的策略？

在 Go 语言中，死锁是指两个或多个 goroutine 等待其他goroutine 释放资源时的状态。死锁可能会导致程序无法正常执行，从而影响系统性能。死锁的避免策略如下：

var mu sync.Mutex
func criticalSection() {
    mu.Lock()
    // 执行需要互斥的代码
    mu.Unlock()
}

ch := make(chan int)
func consumer() {
    for {
        v := <-ch
        // 处理数据
    }
}
func producer() {
    ch <- 42 // 发送数据
}
go consumer()
go producer()

type CancelFunc func()
func goExecute(ctx context.Context, f CancelFunc) {
    select {
    case <-ctx.Done():
        f() // 取消函数
    default:
        // 执行函数
    }
}

  1. 确保资源正确释放。在函数退出之前，确保所有分配的资源（如缓冲区、文件句柄等）都被正确释放，以避免资源泄露。

  2. 合理设计程序结构。确保程序中的 goroutine 和通道的使用是合理的，不引入死锁。例如，避免在同一个函数中使用无限循环或等待通道。

  3. 使用 go 函数 的错误处理。在创建 goroutine 时，可以使用 go func() error 形式来处理错误。这样可以确保在 goroutine 发生错误时，主程序可以捕获并处理错误。

  4. 使用 context.Context。在需要控制 goroutine 执行的情况下，可以使用 context.Context 传递取消函数。这样可以确保在程序需要时取消 goroutine。

avatar
文章
阅读
粉丝