go 实现两个协程交替打印1-100的奇偶数

package main

import "fmt"

func main() {
    // 定义无缓冲通道，用于协程间同步
    ch := make(chan struct{})

    // 奇数协程：打印1,3,5...99
    go func() {
        for i := 1; i <= 100; i += 2 {
            // 先打印奇数
            fmt.Printf("奇数协程：%d\n", i)
            // 发送信号，通知偶数协程执行（无缓冲通道会阻塞，直到对方接收）
            ch <- struct{}{}
            // 等待偶数协程执行完的信号（再次阻塞，等待对方发送）
            <-ch
        }
        // 奇数打印完毕后，关闭通道，让偶数协程退出循环
        close(ch)
    }()

    // 偶数协程：打印2,4,6...100
    go func() {
        for i := 2; i <= 100; i += 2 {
            // 等待奇数协程的信号（阻塞，直到奇数协程发送）
            _, ok := <-ch
            if !ok { // 通道关闭则退出
                return
            }
            // 打印偶数
            fmt.Printf("偶数协程：%d\n", i)
            // 发送信号，通知奇数协程执行
            ch <- struct{}{}
        }
    }()

    // 主协程等待子协程执行完毕（避免主协程提前退出）
    var wg sync.WaitGroup
    wg.Add(2)
    // 上面两个协程里分别加 wg.Done()，这里简化用for循环阻塞（实际开发用WaitGroup更规范）
    for i := 1; i <= 100; i++ {
        if i%100 == 0 {
            break
        }
    }
}

package main

import (
    "fmt"
    "sync"
)

func main() {
    var (
        mu        sync.Mutex   // 互斥锁，保护临界区
        isOddTurn bool         // 标志位：true表示该奇数协程执行，false表示该偶数协程
        wg        sync.WaitGroup // 等待组，等待两个协程执行完毕
        count     int          // 计数器，记录当前要打印的数字
    )

    wg.Add(2)

    // 奇数协程
    go func() {
        defer wg.Done()
        for count <= 100 {
            mu.Lock() // 加锁，进入临界区
            // 只有当轮到奇数且count是奇数时才打印
            if isOddTurn && count%2 == 1 {
                fmt.Printf("奇数协程：%d\n", count)
                count++               // 计数器自增
                isOddTurn = false     // 切换到偶数协程的回合
            }
            mu.Unlock() // 解锁，离开临界区
        }
    }()

    // 偶数协程
    go func() {
        defer wg.Done()
        for count <= 100 {
            mu.Lock()
            // 只有当轮到偶数且count是偶数时才打印
            if !isOddTurn && count%2 == 0 {
                fmt.Printf("偶数协程：%d\n", count)
                count++
                isOddTurn = true      // 切换到奇数协程的回合
            }
            mu.Unlock()
        }
    }()

    // 初始化标志位：先让奇数协程执行
    isOddTurn = true
    // 等待两个协程执行完毕
    wg.Wait()
}

package main

import (
    "fmt"
    "sync"
)

func main() {
    var (
        mu        sync.Mutex   // 条件变量必须配合互斥锁使用
        cond      = sync.NewCond(&mu) // 初始化条件变量
        isOddTurn bool         // 标志位
        wg        sync.WaitGroup
        count     int
    )

    wg.Add(2)

    // 奇数协程
    go func() {
        defer wg.Done()
        for count <= 100 {
            mu.Lock()
            // 循环等待：不是自己的回合或count不是奇数时，进入等待
            for !isOddTurn || count%2 != 1 {
                cond.Wait() // 释放锁并等待，被唤醒后重新加锁
            }
            // 满足条件，打印并更新状态
            fmt.Printf("奇数协程：%d\n", count)
            count++
            isOddTurn = false
            cond.Signal() // 唤醒一个等待的协程（这里唤醒偶数协程）
            mu.Unlock()
        }
    }()

    // 偶数协程
    go func() {
        defer wg.Done()
        for count <= 100 {
            mu.Lock()
            // 循环等待：不是自己的回合或count不是偶数时，进入等待
            for isOddTurn || count%2 != 0 {
                cond.Wait()
            }
            // 满足条件，打印并更新状态
            fmt.Printf("偶数协程：%d\n", count)
            count++
            isOddTurn = true
            cond.Signal() // 唤醒奇数协程
            mu.Unlock()
        }
    }()

    // 初始化：让奇数协程先执行
    isOddTurn = true
    cond.Signal() // 唤醒第一个协程（奇数协程）
    wg.Wait()
}

package main

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

func main() {
    var (
        count int32         // 原子计数器（必须用int32/int64等原子类型）
        wg    sync.WaitGroup
    )

    wg.Add(2)

    // 奇数协程
    go func() {
        defer wg.Done()
        for {
            // 原子读取count的值
            current := atomic.LoadInt32(&count)
            if current > 100 {
                return
            }
            // 是奇数且当前值等于计数器（避免被其他协程修改）
            if current%2 == 1 {
                fmt.Printf("奇数协程：%d\n", current)
                // 原子自增count（CAS操作更安全，这里简化用Add）
                atomic.AddInt32(&count, 1)
            }
        }
    }()

    // 偶数协程
    go func() {
        defer wg.Done()
        for {
            current := atomic.LoadInt32(&count)
            if current > 100 {
                return
            }
            if current%2 == 0 {
                fmt.Printf("偶数协程：%d\n", current)
                atomic.AddInt32(&count, 1)
            }
        }
    }()

    // 初始化count为1（奇数先开始）
    atomic.StoreInt32(&count, 1)
    wg.Wait()
}