Go事件每触发两次仅处理一次的问题求助

相关代码 #

settings_manager.go #

package main

type Settings struct {
    globalTrackingDisabled      bool
    textTracking                bool
    imageTracking               bool
    debug                       bool
    Event                       chan string
    EventTextTracking           string
    EventImageTracking          string
    EventGlobalTrackingDisabled string
    EventDebugToggled           string
}

type DefaultValues struct {
    GlobalTrackingDisabled bool
    TextTracking           bool
    ImageTracking          bool
    DebugEnabled           bool
}

func NewSettings(defaults DefaultValues) *Settings {
    return &Settings{
        globalTrackingDisabled:      defaults.GlobalTrackingDisabled,
        textTracking:                defaults.TextTracking,
        imageTracking:               defaults.ImageTracking,
        debug:                       defaults.DebugEnabled,
        Event:                       make(chan string, 1), // 缓冲大小为1的通道
        EventTextTracking:           "textTracking",
        EventImageTracking:          "imageTracking",
        EventGlobalTrackingDisabled: "globalTrackingDisabled",
        EventDebugToggled:           "debugToggled",
    }
}

// 获取textTracking当前值
func (s *Settings) TextTrackingEnabled() bool {
    return s.textTracking
}

// 获取imageTracking当前值
func (s *Settings) ImageTrackingEnabled() bool {
    return s.imageTracking
}

// 获取globalTrackingDisabled当前值
func (s *Settings) GlobalTrackingDisabled() bool {
    return s.globalTrackingDisabled
}

// 获取textTracking的反值
func (s *Settings) TextTrackingDisabled() bool {
    return !s.TextTrackingEnabled()
}

// 获取imageTracking的反值
func (s *Settings) ImageTrackingDisabled() bool {
    return !s.ImageTrackingEnabled()
}

// 获取globalTrackingDisabled的反值
func (s *Settings) GlobalTrackingEnabled() bool {
    return !s.GlobalTrackingDisabled()
}

// 获取debug当前值
func (s *Settings) Debug() bool {
    return s.debug
}

// 设置全局追踪状态并触发事件（存在逻辑bug）
func (s *Settings) SetGlobalTracking(value bool) {
    s.textTracking = value
    s.Event <- s.EventGlobalTrackingDisabled
}

// 设置文本追踪状态并触发事件
func (s *Settings) SetTextTracking(value bool) {
    Debug("setter to ", value, s.EventTextTracking)
    s.textTracking = value
    s.Event <- s.EventTextTracking
    Debug("Sent event %s\n", s.EventTextTracking)
}

// 设置图片追踪状态并触发事件
func (s *Settings) SetImageTracking(value bool) {
    s.imageTracking = value
    s.Event <- s.EventImageTracking
}

// 设置debug状态并触发事件
func (s *Settings) SetDebug(value bool) {
    s.debug = value
    s.Event <- s.EventDebugToggled
}

// 关闭debug并触发事件
func (s *Settings) DebugDisable() {
    s.debug = false
    s.Event <- s.EventDebugToggled
}

// 开启debug并触发事件
func (s *Settings) DebugEnable() {
    s.debug = true
    s.Event <- s.EventDebugToggled
}

菜单项点击逻辑 #

// 点击事件处理
go func() {
    for {
        select {
        case <-captureTextMenuItem.ClickedCh:
            Debug("Menu item clicked. New Value should be ", !captureTextMenuItem.Checked())
            if captureTextMenuItem.Checked() {
                settings.SetTextTracking(false)
            } else {
                settings.SetTextTracking(true)
            }
            //settings.SetTextTracking(!settings.TextTrackingEnabled())
            //Debug(settings.TextTrackingEnabled())
        }
    }
}()

全局事件处理逻辑 #

// 事件处理程序
go func() {
    for {
        select {
        case event := <-settings.Event:
            Debug("Received Event", event)
            switch event {
            case settings.EventTextTracking:
                Debug("Ready to do something with the text event")
                if settings.TextTrackingEnabled() {
                    Debug("Enabling checkmark")
                    captureTextMenuItem.Check()
                } else {
                    Debug("Removing checkmark")
                    captureTextMenuItem.Uncheck()
                }
            case settings.EventGlobalTrackingDisabled:
                Debug("Ready to do something with the global tracker event")
                if settings.GlobalTrackingEnabled() {
                    Debug("enabling global tracker")
                    captureTextMenuItem.Enable()
                } else {
                    Debug("disabling global tracker")
                    captureTextMenuItem.Disabled()
                }
            default:
                fmt.Println("received unknown event:", event)
            }
        }
    }
}()

问题原因 #

1. 带缓冲通道的事件堆积：Event通道设置了大小为1的缓冲，当连续触发事件时，若前一个事件未被及时处理，新事件会存入缓冲，但后续的发送操作可能因缓冲满而阻塞，或导致事件处理不及时。
2. 点击逻辑依赖菜单项状态而非设置状态：点击时根据菜单项的选中状态切换设置，但事件处理程序会修改菜单项状态，若systray库在代码修改菜单项状态时也触发ClickedCh事件，会导致重复调用SetTextTracking，形成无效的事件循环。
3. SetGlobalTracking函数存在逻辑bug：误将globalTrackingDisabled的设置逻辑写成修改textTracking，虽不直接影响当前问题，但会导致全局追踪功能异常。

修复方案 #

1. 将事件通道改为无缓冲 #

无缓冲通道能确保事件发送必须等待接收方处理完成，避免事件堆积和阻塞问题：

// 修改NewSettings中的通道创建逻辑
Event: make(chan string), // 移除缓冲大小，改为无缓冲通道

2. 修改点击逻辑，基于设置状态切换 #

直接根据settings的当前状态切换，避免依赖菜单项的可能不同步状态：

// 点击事件处理
go func() {
    for {
        select {
        case <-captureTextMenuItem.ClickedCh:
            newVal := !settings.TextTrackingEnabled()
            Debug("Menu item clicked. New Value should be ", newVal)
            settings.SetTextTracking(newVal)
        }
    }
}()

3. 修复SetGlobalTracking的逻辑bug #

修正全局追踪状态的设置逻辑：

func (s *Settings) SetGlobalTracking(value bool) {
    s.globalTrackingDisabled = !value // 根据业务需求调整，确保修改的是正确字段
    s.Event <- s.EventGlobalTrackingDisabled
}

内容的提问来源于stack exchange，提问作者TylerMills