Go语言并发编程：实现安全的Goroutine计数与同步

type Queue struct {
    records string
    count   int64 // 用于计数的字段
}

// 错误示例：值接收器，无法修改原始Queue的count
func (q Queue) push(record chan interface{}) {
    // ...
    // q.count++ // 这里的修改只作用于q的副本
}

// 正确示例：指针接收器，可以修改原始Queue的count
func (q *Queue) push(record chan interface{}) {
    // ...
    // q.count++ // 这里的修改将作用于原始Queue
}

import (
    "sync/atomic"
    "log" // 用于打印日志
)

type Queue struct {
    records string
    count   int64 // 计数器，类型为int64以配合atomic操作
}

func (q *Queue) push(record chan interface{}) {
    record <- time.Now() // 模拟数据推送

    // 原子地增加计数器，并获取新值
    newcount := atomic.AddInt64(&q.count, 1)
    log.Printf("Push: %d", newcount) // 打印当前计数
}

func (q *Queue) pop(record chan interface{}) {
    <-record // 模拟数据弹出

    // 原子地减少计数器，并获取新值
    newcount := atomic.AddInt64(&q.count, -1)
    log.Printf("Pop: %d", newcount) // 打印当前计数
}

package main

import (
    "log"
    "runtime"
    "sync"
    "sync/atomic"
    "time"
)

const SizePerThread = 10000000 // 每个Goroutine操作的数据量

// Queue结构体，包含数据记录和原子计数器
type Queue struct {
    records string
    count   int64 // 使用int64类型以支持sync/atomic操作
}

// push 方法：使用指针接收器修改Queue状态，并原子地增加计数
func (q *Queue) push(record chan interface{}) {
    record <- time.Now() // 模拟数据推送，实际应用中可以是任何数据

    // 原子地增加计数器
    newcount := atomic.AddInt64(&q.count, 1)
    // log.Printf("Push: %d", newcount) // 可选：打印每次操作后的计数
}

// pop 方法：使用指针接收器修改Queue状态，并原子地减少计数
func (q *Queue) pop(record chan interface{}) {
    <-record // 模拟数据弹出

    // 原子地减少计数器
    newcount := atomic.AddInt64(&q.count, -1)
    // log.Printf("Pop: %d", newcount) // 可选：打印每次操作后的计数
}

func main() {
    // 设置Go程序可以使用的最大CPU核心数
    runtime.GOMAXPROCS(runtime.NumCPU())

    // 初始化一个WaitGroup，用于等待所有Goroutine完成
    var wg sync.WaitGroup

    // 创建一个带缓冲的通道，模拟队列
    // 缓冲区大小应根据实际需求和内存限制设置
    record := make(chan interface{}, 1000000)
    // 初始化Queue实例
    queue := new(Queue)

    // 我们将启动10个push Goroutine和10个pop Goroutine，共20个
    // 告知WaitGroup需要等待20个任务
    wg.Add(20)

    // 启动10个Goroutine进行数据推送
    for i := 0; i < 10; i++ {
        go func() {
            defer wg.Done() // Goroutine完成后调用Done()减少计数器

            for j := 0; j < SizePerThread; j++ {
                queue.push(record)
            }
        }()
    }

    // 启动10个Goroutine进行数据弹出
    for i := 0; i < 10; i++ {
        go func() {
            defer wg.Done() // Goroutine完成后调用Done()减少计数器

            for j := 0; j < SizePerThread; j++ {
                queue.pop(record)
            }
        }()
    }

    // 阻塞主Goroutine，直到所有20个Goroutine都调用了Done()
    wg.Wait()

    // 所有Goroutine完成后，打印最终的计数器值
    // 理论上，如果push和pop数量相同，且都已完成，最终计数应为0
    log.Printf("所有Goroutine完成，最终计数: %d", atomic.LoadInt64(&queue.count))
    log.Println("程序执行完毕。")
}