Question

所以我有一些事件队列和几个goroutine，它们在无限循环中从相应的队列中获取事件，处理它们，并将结果发送到一个通道。不同的队列可能会给你相同的事件，所以我需要确保每个事件只发送到通道一次，并且将忽略该消息在另一个队列中的任何出现。我认为这更像是一个架构问题，但我无法弄清楚如何正确处理这个问题。

我当前代码的简化版本如下。

获取和处理传入事件的Goroutines看起来有点像这样：

func (q *Queue) ProcessEvents(handler Handler) {
   lastEvent = 0
   for {
       events = getEvents(lastEvent)
       for _, e := range events {
           if e.ID > lastEvent  {
                lastEvent = event.ID
           }
           handler.Handle(e)
       }
   }
}

处理程序：

type Handler struct {
    c chan Event
}

func (h *Handler) Handle(event *Event) {
    //event processing omitted
    h.c <- event //Now it just sends a processed event into the channel no matter what.
}

在main（）中我做了

func main() {
    msgc := make(chan Event)
    for _, q := range queues {
        go func(queue Queue) {
            queue.ProcessEvents(&Handler{msgc})
        }
    }
}

Answer 1

所以你代表你当前的架构如下：

使用这种类型的解决方案，Generators需要检查共享资源以查看是否已发出事件。这可能看起来像这样：

var hasEmmited map[string]bool
var lock sync.Mutex

func HasEmitted(event e) bool {
   lock.Lock()
   defer lock.Unlock()
   e,ok := hasEmmited[e.ID]
   return e && ok
}

func SetEmmited(event e) {
   lock.Lock()
   defer lock.Lock()
   hasEmmited[e.ID] = true
}

这需要锁定/解锁，即使在没有争用的最佳情况下，考虑到在关键部分中进行的少量工作，这也是一个很好的开销。

如果在体系结构中进行了少量更改，就像在第二个图中一样，一个go-routine就可以在没有任何锁定的情况下进行过滤。

一些评论者表示，使用go-routines设计解决方案与设计单线程应用程序相同。我不相信这种情况。我建议看看：

Golang相关消息：https://blog.golang.org/pipelines

一些消息处理设计模式：http://www.enterpriseintegrationpatterns.com/

企业集成模式在这里可能看起来不合适，但它涵盖了许多也适用于go的消息传递模式。

Goroutines和消息重复数据删除

1 个答案: