Go中使用RegisterHotkey与PeekMessageW的延迟异常问题

我正在用Go编写一个后台监听Windows全局热键的程序，按下指定热键时发送API请求。这是我第一次接触Windows消息机制，可能存在理解误区。

目前遇到的问题是：调用PeekMessageW时，明明按下热键却经常返回0，大约1分钟后又突然批量返回所有积压的消息。这是预期行为吗？

所有操作都在同一个goroutine中执行，流程如下：

1. 创建窗口并获取HWND #

func createWindow(
    user32 *syscall.DLL,
    dwExStyle uint32,
    lpClassName, lpWindowName *uint16,
    dwStyle uint32,
    x, y, nWidth, nHeight int,
    hWndParent, hMenu, hInstance uintptr,
    lpParam unsafe.Pointer,
) uintptr {
    procCreateWindowEx := user32.MustFindProc("CreateWindowExW")

    ret, _, _ := procCreateWindowEx.Call(
        uintptr(dwExStyle),
        uintptr(unsafe.Pointer(lpClassName)),
        uintptr(unsafe.Pointer(lpWindowName)),
        uintptr(dwStyle),
        uintptr(x),
        uintptr(y),
        uintptr(nWidth),
        uintptr(nHeight),
        hWndParent,
        hMenu,
        hInstance,
        uintptr(lpParam),
    )
    return ret
}

func GiveSimpleWindowPls(user32 *syscall.DLL) uintptr {
    var hwnd uintptr
    className, _ := syscall.UTF16PtrFromString("STATIC")
    windowName, _ := syscall.UTF16PtrFromString("Simple Window")

    hwnd = createWindow(
        user32,
        0,
        className,
        windowName,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        nil,
    )

    if hwnd != 0 {
        fmt.Println("HWND:", hwnd)
    } else {
        fmt.Println("Could not create window")
    }
    return hwnd
}

2. 注册热键 #

func Register(user32 *syscall.DLL, hwnd uintptr) (map[int]*Hotkey, error) {
    reghotkey := user32.MustFindProc("RegisterHotKey")

    // Hotkeys to listen to:
    // (hardcoded for now)
    keys := map[int]*Hotkey{
        6:  {6, ModAlt + ModCtrl + ModShift, '6'},
        7:  {7, ModAlt + ModCtrl + ModShift, '7'},
        8:  {8, ModAlt + ModCtrl + ModShift, '8'},
        9:  {9, ModAlt + ModCtrl + ModShift, '9'},
        10: {10, ModAlt + ModCtrl + ModShift, '0'},
    }

    // Register hotkeys:
    for _, v := range keys {
        r1, _, err := reghotkey.Call(hwnd, uintptr(v.Id), uintptr(v.Modifiers), uintptr(v.KeyCode))
        if r1 != 1 {
            return nil, fmt.Errorf("error registering hotkey %#v: %w", v, err)
        }
    }
    return keys, nil
}

3. 循环调用PeekMessageW监听消息 #

const WM_HOTKEY = 0x0312

func Listen(keys map[int]*Hotkey, switcher Switcher, hwnd uintptr) {
    peekmsg := user32.MustFindProc("PeekMessageW")

    for {
        var msg = &MSG{}
        a, _, _ := peekmsg.Call(uintptr(unsafe.Pointer(msg)), hwnd, WM_HOTKEY, WM_HOTKEY, 1)
        fmt.Printf("%#v %d \n", msg, a)

        if a == 0 {
            time.Sleep(time.Millisecond * 50)
            continue
        }

        if key, ok := keys[int(msg.WPARAM)]; ok {
            fmt.Println("Hotkey was pressed:", key)

            switcher.Switch(key.Id) // for now this just does nothing and returns
        }
    }
}

程序起初运行正常，但每隔约1分钟，PeekMessageW就只返回0，即便持续按热键也无响应，之后又突然批量处理所有积压的消息。

我想知道：

• 我是否错误地期望能立即（或几秒内）获取WM_HOTKEY消息？
• 程序有时停止接收消息长达1分钟，之后一次性处理所有消息，是否是Windows为其他进程优先占用了消息队列？

我已经花了数小时搜索解决方案，但仍未找到问题所在。

解决方案 #

问题根源

核心问题在于未遵循Windows消息队列的标准处理逻辑：

1. 使用PeekMessageW配合time.Sleep会导致线程频繁进入休眠状态，Windows会降低该线程的消息调度优先级，甚至暂时缓存消息，最终造成批量积压。
2. 你创建的STATIC类窗口虽能接收WM_HOTKEY，但缺少规范的消息循环，无法及时派发和处理消息。

修复步骤

1. 替换为标准消息循环（GetMessageW+DispatchMessageW）

GetMessageW是阻塞式调用，没有消息时线程会进入系统等待状态，不会占用CPU，同时保证消息能被即时处理：

func Listen(keys map[int]*Hotkey, switcher Switcher, hwnd uintptr) {
    user32 := syscall.MustLoadDLL("user32.dll")
    getMsg := user32.MustFindProc("GetMessageW")
    dispatchMsg := user32.MustFindProc("DispatchMessageW")
    translateMsg := user32.MustFindProc("TranslateMessage")

    var msg MSG
    for {
        // GetMessageW阻塞直到有消息到来，返回0表示收到WM_QUIT
        ret, _, _ := getMsg.Call(uintptr(unsafe.Pointer(&msg)), hwnd, WM_HOTKEY, WM_HOTKEY)
        if ret == 0 {
            break
        }

        // 处理键盘消息的字符转换
        translateMsg.Call(uintptr(unsafe.Pointer(&msg)))
        // 派发消息到窗口过程
        dispatchMsg.Call(uintptr(unsafe.Pointer(&msg)))

        if msg.Message == WM_HOTKEY {
            if key, ok := keys[int(msg.WParam)]; ok {
                fmt.Println("Hotkey was pressed:", key)
                switcher.Switch(key.Id)
            }
        }
    }
}

2. 注册自定义窗口类（可选但推荐）

为窗口绑定自定义消息处理过程，避免默认窗口类的潜在问题：

// 窗口过程回调
var windowProc = syscall.NewCallback(func(hwnd uintptr, msg uint32, wParam uintptr, lParam uintptr) uintptr {
    switch msg {
    case WM_HOTKEY:
        // 可在此直接处理热键，或留空让消息循环处理
        return 0
    default:
        // 调用默认窗口过程处理其他消息
        user32 := syscall.MustLoadDLL("user32.dll")
        defWindowProc := user32.MustFindProc("DefWindowProcW")
        ret, _, _ := defWindowProc.Call(hwnd, uintptr(msg), wParam, lParam)
        return ret
    }
})

// 修改窗口创建逻辑
func GiveSimpleWindowPls(user32 *syscall.DLL) uintptr {
    className, _ := syscall.UTF16PtrFromString("CustomHotkeyWindowClass")
    
    // 注册自定义窗口类
    wc := WNDCLASSEX{
        cbSize:        uint32(unsafe.Sizeof(WNDCLASSEX{})),
        lpfnWndProc:   windowProc,
        hInstance:     0, // 使用当前进程实例
        lpszClassName: className,
    }
    registerClass := user32.MustFindProc("RegisterClassExW")
    registerClass.Call(uintptr(unsafe.Pointer(&wc)))

    // 创建窗口
    hwnd := createWindow(
        user32,
        0,
        className,
        syscall.StringToUTF16Ptr("Hotkey Listener"),
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        nil,
    )

    if hwnd != 0 {
        fmt.Println("HWND:", hwnd)
    } else {
        fmt.Println("Could not create window")
    }
    return hwnd
}

// 定义WNDCLASSEX结构体
type WNDCLASSEX struct {
    cbSize        uint32
    style         uint32
    lpfnWndProc   uintptr
    cbClsExtra    int32
    cbWndExtra    int32
    hInstance     uintptr
    hIcon         uintptr
    hCursor       uintptr
    hbrBackground uintptr
    lpszMenuName  *uint16
    lpszClassName *uint16
    hIconSm       uintptr
}

3. 移除time.Sleep

GetMessageW本身会在无消息时让线程进入系统等待，无需额外休眠，这样能保证线程随时响应消息。

关键说明

• Windows不会因为其他进程优先占用消息队列，线程长时间休眠才是消息积压的核心原因——系统会认为该线程无响应，暂时缓存消息直到线程恢复处理能力。
• WM_HOTKEY是即时发送的，只要消息循环符合规范，就能立即收到消息。

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