Golang channel实现观察者事件通知

一分耕耘，一分收获！既然打开了这篇文章《Golang channel实现观察者事件通知》，就坚持看下去吧！文中内容包含等等知识点...希望你能在阅读本文后，能真真实实学到知识或者帮你解决心中的疑惑，也欢迎大佬或者新人朋友们多留言评论，多给建议！谢谢！

Go中观察者模式可通过channel和goroutine实现，核心为Subject维护观察者channel列表，状态变更时通过Notify向各observer广播Event，利用RWMutex保证并发安全，select+default实现非阻塞通知，Close方法关闭所有channel防止泄漏，适用于事件驱动架构。

在Go语言中，观察者模式可以通过channel和goroutine天然地实现事件通知机制。这种模式适用于解耦事件发布者和多个订阅者，比如在系统状态变更、消息广播或事件驱动架构中非常实用。

观察者模式核心思想

观察者模式定义了一种一对多的依赖关系，当一个对象（被观察者）的状态发生变化时，所有依赖它的对象（观察者）都会收到通知并自动更新。

在Go中，我们可以使用channel作为消息传递的媒介，利用其并发安全的特性，避免显式加锁。

基本结构设计

我们需要三个核心组件：

• Event：表示事件数据
• Observer：接收事件的订阅者
• Subject：事件发布者，维护观察者列表并通过channel广播

以下是一个简洁的实现示例：

package main

import (
    "fmt"
    "sync"
)

// Event 事件结构
type Event struct {
    Type string
    Data interface{}
}

// Observer 观察者接口
type Observer interface {
    Update(event Event)
}

// Subject 被观察者
type Subject struct {
    observers []chan Event // 所有观察者的channel
    mutex     sync.RWMutex
    closed    bool
}

func NewSubject() *Subject {
    return &Subject{
        observers: make([]chan Event, 0),
        closed:    false,
    }
}

// Subscribe 添加观察者，返回用于接收事件的channel
func (s *Subject) Subscribe() <-chan Event {
    s.mutex.Lock()
    defer s.mutex.Unlock()

    if s.closed {
        return nil
    }

    ch := make(chan Event, 10) // 带缓冲避免阻塞
    s.observers = append(s.observers, ch)
    return ch
}

// Notify 通知所有观察者
func (s *Subject) Notify(event Event) {
    s.mutex.RLock()
    defer s.mutex.RUnlock()

    for _, ch := range s.observers {
        select {
        case ch <- event:
        default:
            // 非阻塞发送，观察者处理慢也不会影响发布者
        }
        }
    }
}

// Close 关闭所有观察者channel
func (s *Subject) Close() {
    s.mutex.Lock()
    defer s.mutex.Unlock()

    if s.closed {
        return
    }
    s.closed = true

    for _, ch := range s.observers {
        close(ch)
    }
    s.observers = nil
}

使用示例

下面演示如何使用上述实现：

func main() {
    subject := NewSubject()

    // 创建两个观察者
    observer1 := subject.Subscribe()
    observer2 := subject.Subscribe()

    // 启动两个监听goroutine
    go func() {
        for event := range observer1 {
            fmt.Printf("Observer1 收到事件: %s, 数据: %v\n", event.Type, event.Data)
        }
        fmt.Println("Observer1 已关闭")
    }()

    go func() {
        for event := range observer2 {
            fmt.Printf("Observer2 收到事件: %s, 数据: %v\n", event.Type, event.Data)
        }
        fmt.Println("Observer2 已关闭")
    }()

    // 发布事件
    subject.Notify(Event{Type: "user.login", Data: "alice"})
    subject.Notify(Event{Type: "system.update", Data: "v1.0.0"})

    // 模拟运行一段时间后关闭
    subject.Close()

    // 防止主goroutine退出过早
    select {}
}

关键设计点说明

并发安全：使用sync.RWMutex保护观察者列表的读写操作，确保多goroutine环境下安全。

非阻塞通知：通过select...default实现非阻塞发送，避免某个观察者处理缓慢拖慢整个系统。

资源释放：提供Close()方法关闭所有channel，防止goroutine泄漏。

缓冲channel：每个观察者使用带缓冲的channel，提升异步处理能力。

基本上就这些。这种基于channel的实现简洁、高效，符合Go的并发哲学，适合大多数事件通知场景。

到这里，我们也就讲完了《Golang channel实现观察者事件通知》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于golang,Goroutine,channel,观察者模式,事件通知的知识点！