详解Go并发编程时如何避免发生竞态条件和数据竞争

目录

• 会发生竞态条件和数据竞争的场景有哪些
• 避坑办法
• 实战场景
• 1.互斥锁
• 2.读写锁
• 3.原子操作
• 4.通道
• 5.WaitGroup
• 6.Context

会发生竞态条件和数据竞争的场景有哪些

• 多个 goroutine 对同一变量进行读写操作。例如，多个 goroutine 同时对一个计数器变量进行增加操作。
• 多个 goroutine 同时对同一数组、切片或映射进行读写操作。例如，多个 goroutine 同时对一个切片进行添加或删除元素的操作。
• 多个 goroutine 同时对同一文件进行读写操作。例如，多个 goroutine 同时向同一个文件中写入数据。
• 多个 goroutine 同时对同一网络连接进行读写操作。例如，多个 goropythonutine 同时向同一个 TCP 连接中写入数据。
• 多个 goroutine 同时对同一通道进行读写开发者_Python培训操作。例如，多个 goroutine 同时向同一个无缓冲通道中发送数据或接收数据。

所以，我们要明白的一点是：只要多个 goroutine 并发访问了共享资源，就有可能出现竞态条件和数据竞争。

避坑办法

现在，我们已经知道了。在编写并发程序时，如果不谨慎，没有考虑清楚共享资源的访问方式和同步机制，那么就会发生竞态条件和数据竞争这些问题，那么如何避免踩坑？避免发生竞态条件和数据竞争的办法有哪些？请看下面：

• 互斥锁：使用 sync 包中的 Mutex 或者 RWMutex，通过对共享资源加锁来保证同一时间只有一个 goroutine 访问。
• 读写锁：使用 sync 包中的 RWMutex，通过读写锁的机制来允许多个 goroutine 同时读取共享资源，但是只允许一个 goroutine 写入共享资源。
• 原子操作：使用 sync/atomic 包中提供的原子操作，可以对共享变量进行原子操作，从而保证不会出现竞态条件和数据竞争。
• 通道：使用 Go 语言中的通道机制，可以将数据通过通道传递，从而避免直接对共享资源的访问。
• WaitGroup：使用 sync 包中的 WaitGroup，可以等待多个 goroutine 完成后再继续执行，从而保证多个 goroutine 之间的顺序性。
• Context：使用 context 包中的 Context，可以传递上下文信息并控制多个 goroutine 的生命周期，从而避免出现因为某个 goroutine 阻塞导致整个程序阻塞的情况。

实战场景

1.互斥锁

比如在一个Web服务器中，多个goroutine需要同时访问同一个全局计数器的变量，达到记录网站访问量的目的。

在这种情况下，如果没有对访问计数器的访问进行同步和保护，就会出现竞态条件和数据竞争的问题。假设有两个goroutine A和B，它们同时读取计数器变量的值为N，然后都增加了1并把结果写回计数器，那么最终的计数器值只会增加1而不是2，这就是一个竞态条件。

为了解决这个问题，可以使用锁等机制来保证访问计数器的同步和互斥。在Go中，可以使用互斥锁（sync.Mutex）来保护共享资源。当一个goroutine需要访问共享资源时，它需要先获取锁，然后访问资源并完成操作，最后释放锁。这样就可以保证每次只有一个goroutine能够访问共享资源，从而避免竞态条件和数据竞争问题。

看下面的代码：

package main

import (
 "fmt"
 "sync"
)

var count int
var mutex sync.Mutex

func main() {
 var wg sync.WaitGroup
 // 启动10个goroutine并发增加计数器的值
 for i := 0; i < 10; i++ {
  wg.Add(1)
  go func() {
   // 获取锁
   mutex.Lock()
   // 访问计数器并增加值
   count++
   // 释放锁
   mutex.Unlock()
   wg.Done()
  }()
 }
 // 等待所有goroutine执行完毕
 wg.Wait()
 // 输出计数器的最终值
 fmt.Println(count)
}

在上面的代码中，使用了互斥锁来保护计数器变量的访问。每个goroutine在访问计数器变量之前先获取锁，然后进行计数器的增加操作，最后释放锁。这样就可以保证计数器变量的一致性和正确性，避免竞态条件和数据竞争问题。

具体的思路是，启动每个 goroutine 时调用 wg.Add(1) 来增加等待组的计数器。然后，在所有 goroutine 执行完毕后，调用 wg.Wait() 来等待它们完成。最后，输出计数器的最终值。

请注意，这个假设的场景和这个代码示例，仅仅只是是为了演示如何使用互斥锁来保护共享资源，实际情况可能更加复杂。例如，在实际的运维开发中，如果使用锁的次数过多，可能会影响程序的性能。因此，在实际开发中，还需要根据具体情况选择合适的同步机制来保证并发程序的正确性和性能。

2.读写锁

下面是一个使用 sync 包中的 RWMutex 实现读写锁的代码案例：

package main

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

var (
 count  int
 rwLock sync.RWMutex
)

func readData() {
 // 读取共享数据，获取读锁
 rwLock.RLock()
 defer rwLock.RUnlock()
 fmt.Println("reading data...")
 time.Sleep(1 * time.Second)
 fmt.Printf("data is %d\n", count)
}

func writeData(n int) {
 // 写入共享数据，获取写锁
 rwLock.Lock()
 defer rwLock.Unlock()
 fmt.Println("writing data...")
 time.Sleep(1 * time.Second)
 count = n
 fmt.Printf("data is %d\n", count)
}

func main() {
 // 启动 5 个读取协程
 for i := 0; i < 5; i++ {
  go readData()
 }

 // 启动 2 个写入协程
 for i := 0; i < 2; i++ {
  go writeData(i + 1)
 }

 // 等待所有协程结束
 time.Sleep(5 * time.Second)
}

在这个示例中，有 5 个读取协程和 2 个写入协程，它们都会访问一个共享的变量 count。读取协程使用 RLock() 方法获取读锁，写入协程使用 Lock() 方法获取写锁。通过读写锁的机制，多个读取协程可以同时读取共享数据，而写入协程则会等待读取协程全部结束后才能执行，从而避免了读取协程在写入协程执行过程中读取到脏数据的问题。

3.原子操作

下面是一个使用 sync/atomic 包中提供的原子操作实现并发安全的计数器的代码案例：

package main

import (
    "fmt"
    "sync/atomic"
    "time"
)

func main() {
    var counter int64

    // 启动 10 个协程对计数器进行增量操作
    for i := 0; i < 10; i++ {
        go func() {
            for j := 0; j < 100; j++ {
                atomic.AddInt64(&counter, 1)
            }
        }()
    }

    // 等待所有协程结束
    time.Sleep(time.Second)

    // 输出计数器的值
    fmt.Printf("counter: %d\n", atomic.LoadInt64(&counter))
}

在这个示例中，有 10 个协程并发地对计数器进行增量操作。由于多个协程同时对计数器进行操作，如果不使用同步机制，就会出现竞态条件和数据竞争。为了保证程序的正确性和健壮性，使用了 sync/atomic 包中提供的原子操作，通过 AddInt64() 方法对计数器进行原子加操作，保证了计数器的并发安全。最后使用 LoadInt64() 方法获取计数器的值并输出。

4.通道

下面是一个使用通道机制实现并发安全的计数器的代码案例：

package main

import (
    "fmt"
    "sync"
)

func main() {
    var counter int

    // 创建一个有缓冲的通道，容量为 10
    ch := make(chan int, 10)

    // 创建一个等待组，用于等待所有协程完成
    var wg sync.WaitGroup
    wg.Add(10)

    // 启动 10 个协程对计数器进行增量操作
    for i := 0; i < 10; i++ {
        go func() {
            for j := 0; j < android10; j++ {
                // 将增量操作发送到通道中
                ch <- 1
            }
            // 任务完成，向等待组发送信号
            wg.Done()
        }()
    }

    // 等待所有协程完成
    wg.Wait()

    // 从通道中接收增量操作并累加到计数器中
    for i := 0; i < 100; i++ {
        counter += <-ch
    }

    // 输出计数器的值
    fmt.Printf("counter: %d\n", counter)
}

在这个示例中，有 10 个协程并发地对计数器进行增量操作。为了避免直接对共享资源的访问，使用了一个容量为 10 的有缓冲通道，将增量操作通过通道传递，然后在主协程中从通道中接收增量操作并累加到计数器中。在协程中使用了等待组等待所有协程完成任务，保证了程序的正确性和健壮性。最后输出计数器的值。

5.WaitGroup

下面是一个使用 sync.WaitGroup 等待多个 Goroutine 完成后再继续执行的代码案例：

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup

    for i := 1; i <= 3; i++ {
        wg.Add(1) // 计数器加1
        go func(i int) {
            defer wg.Done() // 完成时计数器减1
            fmt.Printf("goroutine %d is running\n", i)
        }(i)
    }

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

    fmt.Println("all goroutines have completed")
}

在这个示例中，有 3 个 Goroutine 并发执行，使用 wg.Add(1) 将计数器加1，表示有一个 Goroutine 需要等待。在每个 Goroutine 中使用 defer wg.Done() 表示任务完成，计数器减1。最后使用 wg.Wait() 等待所有 Goroutine 完成任务，然后输出 "all goroutines have completed"。

6.Context

下面是一个使用 context.Context 控制多个 Goroutine 的生命周期的代码案例：

package main

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

func worker(ctx context.Context, id int, wg *sync.WaitGroup) {
    defer wg.Done()

    fmt.Printf("Worker %d started\n",android id)

    for {
        select {
        case <-ctx.Done():
            fmt.Printf("Worker %d stopped\n", id)
            return
        default:
            fmt.Printf("Worker %d is running\n", id)
            time.Sleep(time.Second)
        }
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())

    var wg sync.WaitGroup
    for i := 1; i <= 3; i++ {
        wg.Add(1)
        go worker(ctx, i, &phpwg)
    }

    time.Sleep(3 * time.Second)

    cancel()

    wg.Wait()

    fmt.Println("All workers have stopped")
}

在这个示例中，使用 context.WithCancel 创建了一个上下文，并在 main 函数中传递给多个 Goroutine。每个 Goroutine 在一个 for 循环中执行任务，如果收到了 ctx.Done() 信号就结束任务并退出循环，否则就打印出正在运行的信息并等待一段时间。在 main 函数中，通过调用 cancel() 来发送一个信号，通知所有 Goroutinphpe 结束任务。使用 sync.WaitGroup 等待所有 Goroutine 结束任务，然后输出 "All workers have stopped"。

到此这篇关于详解Go并发编程时如何避免发生竞态条件和数据竞争的文章就介绍到这了,更多相关Go并发编程内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！