在 golang 频道中只有唯一值（没有重复）

Question

在 IoT 设备上，go 应用程序正在运行，可以接收来自云的命令。 命令被推送到队列中

var queue chan time.Time

物联网设备上的工作人员处理队列。

Worker 的工作是将一段时间内的数据回传到云端，通道上的时间就是这段时间的开始时间。 物联网设备在移动网络连接上，因此有时数据会丢失并且永远不会到达云端。 云也不确定它发送的命令是否到达了物联网设备，并且可能会不耐烦并重新发送命令。

我想确保如果原始命令仍在队列中，则不能将相同的命令推送到队列中。 有没有办法做到这一点？

func addToQueue(periodStart time.Time) error {
    if alreadyOnQueue(queue, periodStart) {
        return errors.New("periodStart was already on the queue, not adding it again")
    }
    queue <- periodStart
    return nil
}

func alreadyOnQueue(queue chan time.Time, t time.Time) bool {
    return false // todo
}

Answer 1

我创建了一个在https://github.com/munnik/uniqueue/上可用的解决方案

package uniqueue

import (
    "errors"
    "sync"
)

// UQ is a uniqueue queue. It guarantees that a value is only once in the queue. The queue is thread safe.
// The unique constraint can be temporarily disabled to add multiple instances of the same value to the queue.
type UQ[T comparable] struct {
    back                 chan T
    queue                chan T
    front                chan T
    constraints          map[T]*constraint
    mu                   sync.Mutex
    AutoRemoveConstraint bool // if true, the constraint will be removed when the value is popped from the queue.
}

type constraint struct {
    count    uint // number of elements in the queue
    disabled bool
}

func NewUQ[T comparable](size uint) *UQ[T] {
    u := &UQ[T]{
        back:        make(chan T),
        queue:       make(chan T, size),
        front:       make(chan T),
        constraints: map[T]*constraint{},
    }

    go u.linkChannels()

    return u
}

// Get the back of the queue, this channel can be used to write values to.
func (u *UQ[T]) Back() chan<- T {
    return u.back
}

// Get the front of the queue, this channel can be used to read values from.
func (u *UQ[T]) Front() <-chan T {
    return u.front
}

// Ignores the constraint for a value v once, when the value is added to the queue again, the constraint is enabled again.
func (u *UQ[T]) IgnoreConstraintFor(v T) {
    u.mu.Lock()
    defer u.mu.Unlock()

    if _, ok := u.constraints[v]; !ok {
        u.constraints[v] = &constraint{}
    }

    u.constraints[v].disabled = true
}

// Manually add a constraint to the queue, only use in special cases when you want to prevent certain values to enter the queue.
func (u *UQ[T]) AddConstraint(v T) error {
    u.mu.Lock()
    defer u.mu.Unlock()

    if _, ok := u.constraints[v]; !ok {
        u.constraints[v] = &constraint{
            count:    1,
            disabled: false,
        }
        return nil
    } else {
        if u.constraints[v].disabled {
            u.constraints[v].count += 1
            u.constraints[v].disabled = false
            return nil
        }
    }
    return errors.New("Already existing constraint prevents adding new constraint")
}

// Manually remove a constraint from the queue, this needs to be called when AutoRemoveConstraint is set to false. Useful when you want to remove the constraint only when a worker using the queue is finished processing the value.
func (u *UQ[T]) RemoveConstraint(v T) {
    u.mu.Lock()
    defer u.mu.Unlock()

    if _, ok := u.constraints[v]; ok {
        u.constraints[v].count -= 1
        if u.constraints[v].count == 0 {
            delete(u.constraints, v)
        }
    }
}

func (u *UQ[T]) linkChannels() {
    wg := &sync.WaitGroup{}
    wg.Add(2)

    go u.shiftToFront(wg)
    go u.readFromBack(wg)

    wg.Wait()
}

func (u *UQ[T]) shiftToFront(wg *sync.WaitGroup) {
    for v := range u.queue {
        u.front <- v
        if u.AutoRemoveConstraint {
            u.RemoveConstraint(v)
        }
    }

    close(u.front)

    wg.Done()
}

func (u *UQ[T]) readFromBack(wg *sync.WaitGroup) {
    for v := range u.back {
        if err := u.AddConstraint(v); err == nil {
            u.queue <- v
        }
    }

    close(u.queue)

    wg.Done()
}