go 提供以下数据同步机制：mutex（互斥锁）：限制共享资源的并发访问，避免数据竞争。waitgroup：协调并发任务，确保在所有任务完成前不继续执行。channel（通道）：goroutine 之间通信，发送和接收值，确保有序访问。原子操作：安全地更新共享变量，避免竞态条件。

Golang 函数：并发任务执行中的数据同步机制

在 Go 中执行并发任务时，确保数据的一致性至关重要。本文将探讨 Go 语言中提供的数据同步机制，帮助你实现并发场景下的数据安全访问。

Mutex

立即学习“go语言免费学习笔记（深入）”；

互斥锁（Mutex）是最常用的同步机制之一。它允许一次只有一个 goroutine 访问共享资源，从而防止数据竞争。使用 Mutex 的方式：

import "sync"

var lock sync.Mutex

func myFunc() {
    lock.Lock()
    defer lock.Unlock()
    // 访问共享资源
}

WaitGroup

WaitGroup 用来等待一组 goroutine 完成。这对于协调并发任务和确保在所有任务完成之前不进行进一步的处理非常有用。

import "sync"

var wg sync.WaitGroup

func myFunc() {
    defer wg.Done()
    // 执行任务
}

func main() {
    // 创建一个 goroutine 池
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go myFunc()
    }
    // 等待所有 goroutine 完成
    wg.Wait()
}

channel

通道（channel）是一种用于 goroutine 之间通信的同步机制。通道允许一个 goroutine 将值发送到另一个 goroutine，同时确保接收方在值准备好之前不会阻塞。

import "sync"

var ch chan int

func myFunc(i int) {
    ch <- i
}

func main() {
    ch := make(chan int, 10) // 创建容量为 10 的缓冲通道
    var wg = sync.WaitGroup{}
    defer wg.Wait()
    // 创建一些 goroutine
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            myFunc(i)
        }(i)
    }
    // 从通道中获取结果
    for {
        num := <-ch
        fmt.Println(num)
    }
}

实战案例：并行处理文件

下面是一个并行处理大量文件的实战案例：

import (
    "io/ioutil"
    "sync"
    "sync/atomic"
)

var counter int32 // 原子计数器

func main() {
    var wg sync.WaitGroup
    files := []string{"file1.txt", "file2.txt", "file3.txt"} // 文件列表
    for _, file := range files {
        wg.Add(1)
        go func(file string) {
            defer wg.Done()
            data, err := ioutil.ReadFile(file)
            if err != nil {
                fmt.Println(err)
                return
            }
            // 处理文件数据
            atomic.AddInt32(&counter, 1)
        }(file)
    }
    wg.Wait()
    fmt.Println("Total files processed:", counter)
}

通过使用 WaitGroup 和原子计数器，可以安全地并行处理文件而不丢失数据。

以上就是Golang 函数：并发任务执行中的数据同步机制的详细内容，更多请关注php中文网其它相关文章！