Go语言中并发Goroutine临界区互斥的实现

import "sync"

var mu sync.Mutex // 定义一个互斥锁

func protectedOperation() {
    mu.Lock() // 进入临界区，获取锁
    defer mu.Unlock() // 确保锁在函数退出时被释放，即使发生panic
    // 这里是需要被互斥访问的临界区代码
    // 只有持有锁的Goroutine才能执行到这里
}

package main

import (
    "fmt"
    "sync"
    "time" // 引入time包用于模拟耗时操作
    "math/rand" // 引入rand包用于随机延迟
)

var (
    mutex1, mutex2, mutex3 sync.Mutex // 为每个Routine定义一个主互斥锁
    wg                     sync.WaitGroup // 用于等待所有Goroutine完成
)

func Routine1() {
    mutex1.Lock() // Routine1在整个执行期间持有mutex1
    defer mutex1.Unlock() // 确保mutex1在Routine1结束时被释放
    defer wg.Done() // Routine1完成时通知WaitGroup

    fmt.Println("Routine1: 开始执行前置操作...")
    time.Sleep(time.Duration(rand.Intn(50)) * time.Millisecond) // 模拟前置操作

    for i := 0; i < 5; i++ { // 模拟多次核心操作
        fmt.Println("Routine1: 尝试进入核心操作区...")
        // 核心互斥逻辑：Routine1的打印操作需要获取mutex2和mutex3
        // 这意味着只有当Routine2和Routine3没有持有它们各自的主锁时，Routine1才能进行打印
        mutex2.Lock()
        mutex3.Lock()
        fmt.Printf("Routine1: 核心操作 - 打印消息 %d\n", i)
        time.Sleep(time.Duration(rand.Intn(20)) * time.Millisecond) // 模拟打印耗时
        mutex3.Unlock()
        mutex2.Unlock()
        fmt.Println("Routine1: 核心操作区结束。")
    }

    fmt.Println("Routine1: 执行后置操作...")
    time.Sleep(time.Duration(rand.Intn(50)) * time.Millisecond) // 模拟后置操作
}

func Routine2() {
    mutex2.Lock() // Routine2在整个执行期间持有mutex2
    defer mutex2.Unlock()
    defer wg.Done()

    fmt.Println("Routine2: 开始执行前置操作...")
    time.Sleep(time.Duration(rand.Intn(50)) * time.Millisecond)

    for i := 0; i < 5; i++ {
        fmt.Println("Routine2: 尝试进入核心操作区...")
        // Routine2的打印操作需要获取mutex1和mutex3
        mutex1.Lock()
        mutex3.Lock()
        fmt.Printf("Routine2: 核心操作 - 打印消息 %d\n", i)
        time.Sleep(time.Duration(rand.Intn(20)) * time.Millisecond)
        mutex3.Unlock()
        mutex1.Unlock()
        fmt.Println("Routine2: 核心操作区结束。")
    }

    fmt.Println("Routine2: 执行后置操作...")
    time.Sleep(time.Duration(rand.Intn(50)) * time.Millisecond)
}

func Routine3() {
    mutex3.Lock() // Routine3在整个执行期间持有mutex3
    defer mutex3.Unlock()
    defer wg.Done()

    fmt.Println("Routine3: 开始执行前置操作...")
    time.Sleep(time.Duration(rand.Intn(50)) * time.Millisecond)

    for i := 0; i < 5; i++ {
        fmt.Println("Routine3: 尝试进入核心操作区...")
        // Routine3的打印操作需要获取mutex1和mutex2
        mutex1.Lock()
        mutex2.Lock()
        fmt.Printf("Routine3: 核心操作 - 打印消息 %d\n", i)
        time.Sleep(time.Duration(rand.Intn(20)) * time.Millisecond)
        mutex2.Unlock()
        mutex1.Unlock()
        fmt.Println("Routine3: 核心操作区结束。")
    }

    fmt.Println("Routine3: 执行后置操作...")
    time.Sleep(time.Duration(rand.Intn(50)) * time.Millisecond)
}

func main() {
    rand.Seed(time.Now().UnixNano()) // 初始化随机数种子
    wg.Add(3) // 设置WaitGroup计数为3，表示有3个Goroutine需要等待
    go Routine1()
    go Routine2()
    go Routine3() // 将Routine3也改为并发启动
    wg.Wait() // 等待所有Goroutine完成
    fmt.Println("所有Goroutine执行完毕。")
}

package main

import (
    "fmt"
    "sync"
    "time"
    "math/rand"
)

var commonMutex sync.Mutex // 一个所有Goroutine共享的互斥锁

func performCriticalOperation(id int) {
    fmt.Printf("Goroutine %d: 准备进入临界区...\n", id)
    commonMutex.Lock() // 获取共享锁
    defer commonMutex.Unlock() // 确保锁在函数退出时被释放

    fmt.Printf("Goroutine %d: 进入临界区，执行核心操作...\n", id)
    // 模拟核心操作，例如访问共享变量、IO操作等
    time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)
    fmt.Printf("Goroutine %d: 退出临界区。\n", id)
}

func main() {
    rand.Seed(time.Now().UnixNano())
    var wg sync.WaitGroup

    for i := 1; i <= 3; i++ {
        wg.Add(1)
        go func(goroutineID int) {
            defer wg.Done()
            // 模拟一些前置操作
            time.Sleep(time.Duration(rand.Intn(50)) * time.Millisecond)
            performCriticalOperation(goroutineID) // 调用受互斥锁保护的操作
            // 模拟一些后置操作
            time.Sleep(time.Duration(rand.Intn(50)) * time.Millisecond)
        }(i)
    }

    wg.Wait()
    fmt.Println("所有Goroutine执行完毕。")
}