Go语言并发安全怎样保障

在Go语言中，并发安全可以通过以下几种方式保障：

1. 使用互斥锁（Mutex）：Go标准库中的sync.Mutex和sync.RWMutex提供了互斥锁的功能，可以用来保护共享资源。当一个goroutine获取锁时，其他goroutine必须等待直到锁被释放。

import (
	"fmt"
	"sync"
)

var counter int
var lock sync.Mutex

func increment() {
	lock.Lock()
	counter++
	lock.Unlock()
}

func main() {
	wg := sync.WaitGroup{}
	for i := 0; i < 100; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			increment()
		}()
	}
	wg.Wait()
	fmt.Println("Counter:", counter)
}

1. 使用原子操作（Atomic Operations）：Go标准库中的sync/atomic包提供了一组原子操作函数，可以在不使用锁的情况下对共享变量进行安全的操作。原子操作是不可中断的，因此它们在并发环境中是安全的。

import (
	"fmt"
	"sync/atomic"
)

var counter int32

func increment() {
	atomic.AddInt32(&counter, 1)
}

func main() {
	wg := sync.WaitGroup{}
	for i := 0; i < 100; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			increment()
		}()
	}
	wg.Wait()
	fmt.Println("Counter:", counter)
}

1. 使用通道（Channel）：Go语言中的通道是一种内置的并发同步机制，可以用来在goroutine之间传递数据。通过使用通道，可以确保数据在任何时候只被一个goroutine访问。

import (
	"fmt"
)

func increment(counter chan int) {
	counter <- 1
}

func main() {
	counter := make(chan int, 1)
	counter <- 0

	wg := sync.WaitGroup{}
	for i := 0; i < 100; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			increment(counter)
		}()
	}
	wg.Wait()

	counter <- 0 // Close the channel after all goroutines are done
	finalCounter := <-counter
	fmt.Println("Counter:", finalCounter)
}

1. 使用sync包中的其他同步原语：Go标准库中的sync包还提供了其他同步原语，如sync.WaitGroup、sync.Once等，可以用来实现并发安全的代码。

总之，Go语言通过提供互斥锁、原子操作、通道等机制，可以帮助开发者轻松地实现并发安全的代码。在实际开发中，应根据具体场景选择合适的同步方式。