我正在监听 UDP 上的消息。我们有以这种方式宣布自己的设备。他们还说什么时候发送下一个公告。如果没有发生这种情况，我们假设设备不见了。

我想列出当前网络中的设备。我想添加新设备并移除那些我没有听说过的设备。

这是我到目前为止所得到的。

1) 我有一个内存数据库，其中包含所有设备。

func NewDB() *DB {
    return &DB{
        table: make(map[string]Announcement),
    }
}

type DB struct {
    mutex sync.Mutex
    table map[string]Announcement
}

func (db *DB) Set(ip string, ann Announcement) {
    db.mutex.Lock()
    defer db.mutex.Unlock()
    db.table[ip] = ann
}

func (db *DB) Delete(ip string) {
    db.mutex.Lock()
    defer db.mutex.Unlock()
    delete(db.table, ip)
}

func (db *DB) Snapshot() map[string]Announcement {
    db.mutex.Lock()
    defer db.mutex.Unlock()
    return db.table
}

2) 我有网络服务器将这个数据库提供给我的 JavaScript 前端

http.HandleFunc("/json", func(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(db.Snapshot())
})

// start server
go func() {
    log.Fatal(http.ListenAndServe(":8085", nil))
}()

3) 最后我正在监听 UDP 消息。每当将新设备添加到数据库时，我也会使用提供的超时创建一个新计时器(这里我只是将其设置为 10 秒)。当新消息到达时，我会检查现有计时器，当它存在时停止它，如果它不再发送消息，则再次启动它以清除设备。

然而我并没有真正工作。 AfterFunc 经常被调用。尽管该设备仍在网络中，但它已从我的 db 中删除。有什么想法吗？

// some global variable
var (
    timers = map[string]*time.Timer{}
)

for {
    // create new buffer
    b := make([]byte, 1500)

    // read message from udp into buffer
    n, src, err := conn.ReadFromUDP(b)
    if err != nil {
        panic(err)
    }

    // convert raw json bytes to struct
    var ann Announcement
    if err := json.Unmarshal(b[:n], &ann); err != nil {
        panic(err)
    }

    // add announcement to db
    ip := src.IP.String()
    db.Set(ip, ann)

    // check for existing timer
    timer, ok := timers[ip]
    if ok {
        log.Println("stopping timer", ip)
        // stop existing timer
        timer.Stop()
    }

    // start new timer for device
    timer = time.AfterFunc(time.Second*10, func() {
        log.Println("time after func", ip)
        delete(timers, ip)
        db.Delete(ip)
    })

    // store timer in timers db
    timers[ip] = timer

    time.Sleep(250 * time.Millisecond)
}

最佳答案

我认为您遇到的问题可能与您在 AfterFunc func 中捕获的 ip 变量的值有关。

timer = time.AfterFunc(time.Second*10, func() {
        log.Println("time after func", ip)
        delete(timers, ip)
        db.Delete(ip)
    })

从此代码中，ip 上的 delete 将使用 ip 变量的值调用，此时此计时器到期。因此，如果与此同时您从另一台具有不同 IP 的设备收到数据包，则该设备将被删除。

发生的事情的例子:

• second 1:IP为1.2.3.4的设备发送UDP包。 ip = 1.2.3.4，调用AfterFunc，启动10秒定时器
• second 3:IP为4.5.6.7的设备发送UDP包。现在ip = 4.5.6.7，调用AfterFunc，启动10秒定时器
• second 10:调用删除ip变量当前值的函数，删除设备4.5.6.7
• second 13:第二个定时器超时，我们再次尝试删除4.5.6.7

因此，IP 为 1.2.3.4 的设备永远不会被删除。

您可以通过创建一个接受参数并返回具有当前参数值的 func() 的函数来解决这个问题。

timer = time.AfterFunc(time.Second*10, func(ip string) func() {
    return func() {
        log.Println("time after func", ip)
        delete(timers, ip)
        db.Delete(ip)
    }   
}(ip))

更简单的工作示例:

package main

import (
    "fmt"
    "time"
)

func main() {
    fmt.Println("Capturing value of i at the moment of execution of func()")
    for i := 0; i < 5; i++ {

        afterFuncTimer := time.AfterFunc(time.Second*2, func() {
            fmt.Printf("AfterFunc() with %v\n", i)
        })

        defer afterFuncTimer.Stop()
    }

    time.Sleep(5 * time.Second)

    fmt.Println("Capturing value of i from the loop")
    for i := 0; i < 5; i++ {

        afterFuncTimer := time.AfterFunc(time.Second*2, func(i int) func() {
            return func() {
                fmt.Printf("AfterFunc() with %v\n", i)
            }
        }(i))

        defer afterFuncTimer.Stop()
    }

    time.Sleep(5 * time.Second)

}

在 Go Playground 上运行它:https://play.golang.org/p/bGWzTaWe3ZU

关于go - 在取消 UDP 消息上启动多个计时器，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/51671190/