Go Channel数据重复问题：深度解析与解决方案

package main

import (
    "fmt"
    "time"
)

func main() {
    c := make(chan *int, 1) // 创建一个容量为1的*int类型Channel

    go func() {
        val := new(int) // 仅分配一次内存，得到一个*int指针
        for i := 0; i < 10; i++ {
            *val = i    // 修改*val指向的底层整数值
            c <- val    // 将同一个指针val发送到Channel
            time.Sleep(time.Millisecond * 5) // 模拟一些处理延迟
        }
        close(c)
    }()

    // 消费者协程
    for val := range c {
        time.Sleep(time.Millisecond * 10) // 模拟消费者处理数据所需时间
        fmt.Println(*val)
    }
}

8
9
9
9

func Tail(collection *mgo.Collection, Out chan<- *Operation) {
    iter := collection.Find(nil).Tail(-1)
    for {
        // 内部循环，每次迭代都声明一个新的局部指针变量
        // 确保iter.Next填充的是一个全新的Operation对象
        var oper *Operation // 每次进入内层循环，都会创建一个新的局部变量oper
        if !iter.Next(&oper) { // iter.Next会填充这个新的oper指针指向的Operation对象
            // 如果没有更多记录，或者迭代器出错，则退出内层循环
            if iter.Err() != nil {
                fmt.Println("Iterator error:", iter.Err())
                return
            }
            break // 退出内层循环
        }
        fmt.Println("\n<<", oper.Id)
        Out <- oper // 发送这个新创建的Operation对象的指针
    }
    // ... 处理iter.Close() 和 外层循环的逻辑
}

func Tail(collection *mgo.Collection, Out chan<- *Operation) {
    iter := collection.Find(nil).Tail(-1)
    for {
        // 内部循环，每次迭代都显式分配一个新的Operation对象
        op := new(Operation) // 为每次迭代创建一个新的Operation对象
        if !iter.Next(op) {  // 将新对象的指针传递给iter.Next进行填充
            if iter.Err() != nil {
                fmt.Println("Iterator error:", iter.Err())
                return
            }
            break
        }
        fmt.Println("\n<<", op.Id)
        Out <- op // 发送这个新对象的指针
    }
    // ... 处理iter.Close() 和 外层循环的逻辑
}

package main

import (
    "fmt"
    "time"
)

func main() {
    c := make(chan *int, 1)

    go func() {
        for i := 0; i < 10; i++ {
            val := new(int) // 每次循环都分配一个新的int对象
            *val = i        // 赋值给新的int对象
            c <- val        // 发送指向新int对象的指针
            time.Sleep(time.Millisecond * 5)
        }
        close(c)
    }()

    for val := range c {
        time.Sleep(time.Millisecond * 10)
        fmt.Println(*val)
    }
}

// 假设Channel类型改为 chan Operation
cOper := make(chan Operation, 1) // 注意：Channel现在传递Operation值

// Tail 函数也需要修改，Out 参数类型变为 chan<- Operation
func Tail(collection *mgo.Collection, Out chan<- Operation) {
    iter := collection.Find(nil).Tail(-1)
    for {
        var oper Operation // 声明一个Operation值类型变量
        if !iter.Next(&oper) { // iter.Next填充这个值
            if iter.Err() != nil {
                fmt.Println("Iterator error:", iter.Err())
                return
            }
            break
        }
        fmt.Println("\n<<", oper.Id)
        Out <- oper // 直接发送Operation值，会自动复制
    }
    // ...
}