Go语言并发安全怎样保障_运维文库_资讯中心

发布时间:2026-04-29 07:31:27

阅读量:2

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

使用互斥锁（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)
}

使用原子操作（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)
}

使用通道（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)
}