在取消 UDP 消息上启动多个计时器

Question

我正在收听 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) 我有一个 Web 服务器可以将此数据库提供给我的 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)
}

Answer 1

我认为您遇到的问题可能与您在 AfterFunc func.

中捕获的 ip 变量的值有关

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

从此代码中，ip 上的删除将使用 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 的设备永远不会被删除。

您可以通过创建一个接受参数的函数和 returns 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

在取消 UDP 消息上启动多个计时器

Start multiple timers on UDP message with cancellation

udp

go

goroutine