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

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)
}

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)
}

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))
}

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 < 10; j++ {
                // 将增量操作发送到通道中
                ch <- 1
            }
            // 任务完成，向等待组发送信号
            wg.Done()
        }()
    }

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

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

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

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")
}

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", 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, &wg)
    }

    time.Sleep(3 * time.Second)

    cancel()

    wg.Wait()

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