golang 通道中值无重复的特性

小伙伴们有没有觉得学习Golang很有意思？有意思就对了！今天就给大家带来《golang 通道中值无重复的特性》，以下内容将会涉及到，若是在学习中对其中部分知识点有疑问，或许看了本文就能帮到你！

物联网设备上正在运行的应用程序可以从云接收命令。命令被推送到队列中

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
}

正确答案

我创建了一个解决方案，可通过 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()
}

今天带大家了解了的相关知识，希望对你有所帮助；关于Golang的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~