如何过滤fsnotify监听文件变更时的重复事件消息

DevOps 小满

2026-8-8

如何过滤fsnotify中的重复CREATE/WRITE事件？

我使用github.com/fsnotify/fsnotify监听文件变更，已经通过判断事件类型（如fsnotify.Rename、fsnotify.Create等）减少了部分消息，但仍出现大量重复的CREATE、WRITE事件（示例日志显示同一文件短时间内多次触发相同事件）。已知官方相关Bug已修复，但问题未完全解决，请问该如何过滤这些重复消息？

当前监听代码

func Listener() {
    watcher, err := fsnotify.NewWatcher()
    if err != nil {
        log.Fatal(err)
    }
    defer watcher.Close()
    done := make(chan bool)
    go func() {
        for {
            select {
            case event, ok := <-watcher.Events:
                if !ok {
                    return
                }
                log.Println("event:", event.Name, event.Op)

                // Writing in this way reduces some messages:
                if event.Op&fsnotify.Rename == fsnotify.Rename {
                    // do ...
                } else if event.Op&fsnotify.Create == fsnotify.Create {
                    // do ...
                } else if event.Op&fsnotify.Write == fsnotify.Write {
                    // do ...
                } else if event.Op&fsnotify.Remove == fsnotify.Remove {
                    // do ...
                }
            case _, ok := <-watcher.Errors:
                if !ok {
                    return
                }
            }
        }
    }()
    
    err = watcher.Add("e:/.../demo")
    if err != nil {
        log.Fatal(err)
    }
    <-done
}

重复事件日志示例

2022/12/12 21:00:55 event: e:\...\demo\a.bbb CREATE
2022/12/12 21:00:55 event: e:\...\demo\a.bbb CREATE
2022/12/12 21:00:55 event: e:\...\demo\a.bbb CREATE


2022/12/12 21:01:57 event: e:\...\demo\2.md WRITE
2022/12/12 21:01:57 event: e:\...\demo\2.md WRITE
2022/12/12 21:01:57 event: e:\...\demo\2.md WRITE
2022/12/12 21:01:57 event: e:\...\demo\2.md WRITE
2022/12/12 21:01:57 event: e:\...\demo\2.md WRITE
2022/12/12 21:01:57 event: e:\...\demo\2.md WRITE
2022/12/12 21:01:57 event: e:\...\demo\2.md WRITE

已尝试的过滤代码（需完善）

var syncMap sync.Map
go func() {
    for {
        select {
        case event, ok := <-watcher.Events:
            if !ok {
                return
            }
            fPath := strings.ReplaceAll(event.Name, "\\", "/")
            pathKey, _ := syncMap.Load(fPath)
            if pathKey != 1 {
                // ...
                syncMap.Store(fPath, 1)

                go func() {
                    time.Sleep(time.Second * 2)
                    syncMap.Delete(fPath)
                }()
            }
        case _, ok := <-watcher.Errors:
            if !ok {
                return
            }
        }
    }
}()

可行的重复事件过滤方案

fsnotify产生重复事件的核心原因是底层文件系统（尤其是Windows）会在文件操作时触发多次通知（比如创建文件时的临时写入、权限修改等），即使官方修复了部分Bug，仍需上层做去重处理。以下是几种优化后的过滤方案：

方案1：基于「路径+事件类型」的防抖过滤

你的syncMap方案只过滤了路径，没有区分事件类型，会导致同一文件的CREATE和WRITE事件互相阻塞。优化思路是用路径+事件类型作为Key，并根据事件类型调整防抖时长：

import (
    "strings"
    "sync"
    "time"
    "github.com/fsnotify/fsnotify"
    "log"
)

type EventKey struct {
    Path string
    Op   fsnotify.Op
}

func Listener() {
    watcher, err := fsnotify.NewWatcher()
    if err != nil {
        log.Fatal(err)
    }
    defer watcher.Close()

    var eventCache sync.Map
    done := make(chan bool)

    go func() {
        for {
            select {
            case event, ok := <-watcher.Events:
                if !ok {
                    return
                }
                // 统一路径分隔符，避免Windows和Linux路径格式差异
                normPath := strings.ReplaceAll(event.Name, "\\", "/")
                key := EventKey{Path: normPath, Op: event.Op}

                // 检查是否已有缓存
                if _, exists := eventCache.Load(key); exists {
                    continue
                }

                // 处理事件
                log.Println("处理事件:", event.Name, event.Op)
                switch event.Op {
                case fsnotify.Rename:
                    // do something
                case fsnotify.Create:
                    // do something
                case fsnotify.Write:
                    // do something
                case fsnotify.Remove:
                    // do something
                }

                // 存入缓存并设置过期时间
                eventCache.Store(key, struct{}{})
                go func(k EventKey) {
                    // 根据事件类型设置不同防抖时长：WRITE事件频繁，设短一点；CREATE设长一点
                    var delay time.Duration
                    switch k.Op {
                    case fsnotify.Write:
                        delay = 500 * time.Millisecond
                    case fsnotify.Create, fsnotify.Rename, fsnotify.Remove:
                        delay = 2 * time.Second
                    }
                    time.Sleep(delay)
                    eventCache.Delete(k)
                }(key)

            case err, ok := <-watcher.Errors:
                if !ok {
                    return
                }
                log.Println("错误:", err)
            }
        }
    }()

    err = watcher.Add("e:/.../demo")
    if err != nil {
        log.Fatal(err)
    }
    <-done
}

方案2：基于文件修改时间的过滤（针对WRITE事件）

对于WRITE事件，还可以通过检查文件的最后修改时间来过滤重复事件，确保只在文件真正修改完成后触发一次：

import (
    "os"
    "strings"
    "sync"
    "time"
    "github.com/fsnotify/fsnotify"
    "log"
)

func Listener() {
    watcher, err := fsnotify.NewWatcher()
    if err != nil {
        log.Fatal(err)
    }
    defer watcher.Close()

    var lastModifyTime sync.Map
    done := make(chan bool)

    go func() {
        for {
            select {
            case event, ok := <-watcher.Events:
                if !ok {
                    return
                }
                normPath := strings.ReplaceAll(event.Name, "\\", "/")

                if event.Op&fsnotify.Write == fsnotify.Write {
                    // 获取文件当前修改时间
                    fi, err := os.Stat(normPath)
                    if err != nil {
                        continue
                    }
                    currentTime := fi.ModTime().UnixNano()

                    // 对比缓存的最后修改时间
                    if t, exists := lastModifyTime.Load(normPath); exists && t.(int64) == currentTime {
                        continue
                    }
                    lastModifyTime.Store(normPath, currentTime)

                    // 处理WRITE事件
                    log.Println("处理WRITE事件:", event.Name)
                } else {
                    // 其他事件用防抖过滤
                    if _, exists := lastModifyTime.Load(normPath); exists {
                        continue
                    }
                    lastModifyTime.Store(normPath, struct{}{})
                    go func(path string) {
                        time.Sleep(2 * time.Second)
                        lastModifyTime.Delete(path)
                    }(normPath)

                    // 处理其他事件
                    log.Println("处理事件:", event.Name, event.Op)
                    switch event.Op {
                    case fsnotify.Rename:
                        // do something
                    case fsnotify.Create:
                        // do something
                    case fsnotify.Remove:
                        // do something
                    }
                }

            case err, ok := <-watcher.Errors:
                if !ok {
                    return
                }
                log.Println("错误:", err)
            }
        }
    }()

    err = watcher.Add("e:/.../demo")
    if err != nil {
        log.Fatal(err)
    }
    <-done
}

方案3：合并同路径的连续事件

如果短时间内同一路径产生多个相同事件，可以合并为一次触发，通过缓冲事件并延迟处理实现：

import (
    "strings"
    "time"
    "github.com/fsnotify/fsnotify"
    "log"
)

func Listener() {
    watcher, err := fsnotify.NewWatcher()
    if err != nil {
        log.Fatal(err)
    }
    defer watcher.Close()

    eventChan := make(chan fsnotify.Event)
    done := make(chan bool)

    // 监听事件并转发到缓冲通道
    go func() {
        for {
            select {
            case event, ok := <-watcher.Events:
                if !ok {
                    close(eventChan)
                    return
                }
                eventChan <- event
            case err, ok := <-watcher.Errors:
                if !ok {
                    return
                }
                log.Println("错误:", err)
            }
        }
    }()

    // 缓冲并合并事件
    go func() {
        eventBuffer := make(map[string]fsnotify.Op)
        ticker := time.NewTicker(300 * time.Millisecond)
        defer ticker.Stop()

        for {
            select {
            case event, ok := <-eventChan:
                if !ok {
                    // 处理剩余缓冲事件
                    for path, op := range eventBuffer {
                        log.Println("处理合并事件:", path, op)
                        // do something
                    }
                    done <- true
                    return
                }
                normPath := strings.ReplaceAll(event.Name, "\\", "/")
                // 合并事件：同一路径保留最新的事件类型（比如WRITE覆盖CREATE）
                eventBuffer[normPath] |= event.Op
            case <-ticker.C:
                // 处理缓冲的事件
                for path, op := range eventBuffer {
                    log.Println("处理合并事件:", path, op)
                    switch op {
                    case fsnotify.Rename:
                        // do something
                    case fsnotify.Create:
                        // do something
                    case fsnotify.Write:
                        // do something
                    case fsnotify.Remove:
                        // do something
                    }
                }
                // 清空缓冲
                eventBuffer = make(map[string]fsnotify.Op)
            }
        }
    }()

    err = watcher.Add("e:/.../demo")
    if err != nil {
        log.Fatal(err)
    }
    <-done
}

关键优化点说明

区分事件类型：不同事件的触发频率和场景不同，WRITE事件通常更频繁，需要更短的防抖窗口；CREATE/REMOVE事件可以用较长的窗口。
统一路径格式：替换Windows的\为/，避免路径格式差异导致Key不匹配。
避免 goroutine 泄漏：所有延迟删除的goroutine都要传入当前的Key/Path，避免闭包引用问题。
合并事件而非单纯过滤：对于WRITE事件，合并连续的通知可以确保只在文件操作完成后触发一次，更符合业务需求。

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

如何过滤fsnotify监听文件变更时的重复事件消息

当前监听代码 #

重复事件日志示例 #

已尝试的过滤代码（需完善） #

可行的重复事件过滤方案 #

方案1：基于「路径+事件类型」的防抖过滤 #

方案2：基于文件修改时间的过滤（针对WRITE事件） #

方案3：合并同路径的连续事件 #

关键优化点说明 #