Go语言并发编程怎样保证一致性

发布时间:2024-11-08 13:48:22

阅读量:82

在Go语言中，为了保证并发编程的一致性，我们可以采用以下方法：

使用互斥锁（Mutex）：互斥锁是一种同步原语，用于确保在同一时间只有一个协程（goroutine）可以访问共享资源。Go的sync包提供了Mutex结构体，可以用来实现互斥锁。使用Lock()方法加锁，Unlock()方法解锁。

package main

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

使用读写锁（RWMutex）：读写锁允许多个协程同时读取共享资源，但在写入时会阻止其他协程访问。Go的sync包提供了RWMutex结构体，可以用来实现读写锁。使用RLock()方法加读锁，RUnlock()方法解读锁，Lock()方法加写锁，Unlock()方法解写锁。

package main

import (
 "fmt"
 "sync"
)

var data map[string]string
var rwLock sync.RWMutex

func readData(key string) {
 rwLock.RLock()
 value := data[key]
 rwLock.RUnlock()
 fmt.Println("Read:", value)
}

func writeData(key, value string) {
 rwLock.Lock()
 data[key] = value
 rwLock.Unlock()
}

func main() {
 data = make(map[string]string)
 wg := sync.WaitGroup{}

 for i := 0; i < 10; i++ {
  wg.Add(1)
  go func(i int) {
   defer wg.Done()
   key := fmt.Sprintf("key%d", i)
   value := fmt.Sprintf("value%d", i)
   writeData(key, value)
  }(i)
 }

 for i := 0; i < 100; i++ {
  wg.Add(1)
  go func(i int) {
   defer wg.Done()
   key := fmt.Sprintf("key%d", i%10)
   readData(key)
  }(i)
 }

 wg.Wait()
}

使用原子操作（atomic）：原子操作是一种低级别的同步原语，可以在不使用锁的情况下保证数据的一致性。Go的sync/atomic包提供了一组原子操作函数，如AddInt32()、CompareAndSwapInt32()等。

package main

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

var counter int32
var wg sync.WaitGroup

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

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

使用通道（channel）：通道是Go语言中的一种内置数据结构，可以在协程之间传递数据。通过使用通道，可以实现协程之间的同步和数据一致性。

package main

import (
 "fmt"
 "sync"
)

func worker(wg *sync.WaitGroup, ch chan int) {
 defer wg.Done()
 for i := range ch {
  fmt.Println("Received:", i)
 }
}

func main() {
 ch := make(chan int, 100)
 wg := sync.WaitGroup{}

 for i := 0; i < 10; i++ {
  wg.Add(1)
  go worker(&wg, ch)
 }

 for i := 0; i < 100; i++ {
  ch <- i
 }
 close(ch)

 wg.Wait()
}