当前位置：首页 > 文章列表 > Golang > Go问答 > 简化 For 循环中的上下文

简化 For 循环中的上下文

来源：stackoverflow 2024-03-28 16:48:28 0浏览收藏

推广推荐

支持 PC / 移动端，安全直达

Golang小白一枚，正在不断学习积累知识，现将学习到的知识记录一下，也是将我的所得分享给大家！而今天这篇文章《简化 For 循环中的上下文》带大家来了解一下##content_title##，希望对大家的知识积累有所帮助，从而弥补自己的不足，助力实战开发！

问题内容

我正在尝试在 golang 中创建一个 udp 服务器来监听端口，例如。 1234.我有一个客户端向该服务器发送启动/停止消息。

收到消息“start”后，服务器将开始向该客户端发送随机数据，收到“stop”消息后，服务器将停止向客户端发送数据。

为此，我使用上下文创建一个 goroutine 来发送数据并在“停止”时取消数据。

我收到的错误是程序对于一个客户端运行良好，但如果我再次启动客户端，数据不会再次发送。

如有任何帮助，我们将不胜感激？

udp服务器代码：

package main

import (
    "context"
    "fmt"
    "math/rand"
    "net"
    "time"
)

func generatemessagetoudp(ctx context.context, addr *net.udpaddr) {
    // stop writing to udp
    done := false
    fmt.println("generating message to udp client", addr)
    conn, err := net.dialudp("udp", nil, addr)
    if err != nil {
        fmt.println("error: ", err)
    }
    defer func(conn *net.udpconn) {
        err := conn.close()
        if err != nil {
            fmt.println("error in closing the udp connection: ", err)
        }
    }(conn)
    // write to address using udp connection
    go func() {
        for i := 0; !done; i++ {
            randomint := rand.intn(100)
            fmt.println("random int: ", randomint)
            _, err = conn.write([]byte(fmt.sprintf("%d", randomint)))
            fmt.println("sent ", randomint, " to ", addr)
            time.sleep(time.second * 1)
        }
    }()
    <-ctx.done()
    fmt.println("stopping writing to udp client", addr)
    done = true
}

//var addr *net.udpaddr
//var conn *net.udpconn

func main() {
    fmt.println("hi this is a udp server")
    udpserver, err := net.listenudp("udp", &net.udpaddr{ip: net.ipv4(0, 0, 0, 0), port: 5010})
    if err != nil {
        fmt.println("error: ", err)
    }
    defer func(udpserver *net.udpconn) {
        err := udpserver.close()
        if err != nil {
            fmt.println("error in closing the udp connection: ", err)
        }
    }(udpserver)
    // create a buffer to read data into
    buffer := make([]byte, 1024)
    ctx, cancel := context.withcancel(context.background())
    for {
        // read the incoming connection into the buffer
        n, addr, err := udpserver.readfromudp(buffer)
        fmt.println("recieved ", string(buffer[0:n]), " from ", addr)
        if err != nil {
            fmt.println("error: ", err)
        }
        fmt.println("received ", string(buffer[0:n]), " from ", addr)
        if string(buffer[0:n]) == "stop" {
            fmt.println("stopped listening")
            cancel()
            continue
        } else if string(buffer[0:n]) == "start" {
            // send a response back to the client
            _, err = udpserver.writetoudp([]byte("hi, i am a udp server"), addr)
            if err != nil {
                fmt.println("error: ", err)
            }
            // start a routine to generate messages to the client
            generatemessagetoudp(ctx, addr)
        } else {
            fmt.println("unknown command")
        }
    }
}

客户端代码：

package main

import (
    "fmt"
    "net"
    "time"
)

func main() {
    fmt.Println("Hello, I am a client")

    // Create a new client
    localAddr, err := net.ResolveUDPAddr("udp", ":5011")
    client3, err := net.DialUDP("udp", localAddr, &net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 5010})
    if err != nil {
        fmt.Println(err)
        return
    }
    defer client3.Close()
    _, err = client3.Write([]byte("start"))
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("Message sent. Sleeping for 5 seconds")
    time.Sleep(time.Second * 5)
    fmt.Println("Sending stop message")
    _, err = client3.Write([]byte("stop"))
    if err != nil {
        fmt.Println(err)
    }
}

正确答案

你必须小心你正在做的事情。

避免数据竞争（done 变量由两个不同的例程读取/写入，没有同步机制）https://go.dev/doc/articles/race_detector
每次程序开始向新客户端发送消息时，不要创建新的拨号器。这将打开一个新的本地地址并使用它将其发送给客户端。客户端将从另一个地址接收消息，通常应该忽略该消息，因为它没有发起与该远程地址的任何交换。
不要将客户端生命周期与程序上下文生命周期混淆。在代码中提供的客户端发送停止消息将触发整个程序的取消功能，它将停止所有客户端。为每个客户端创建一个新的上下文，从程序上下文派生，收到停止消息后取消相关的客户端上下文。
udp conns 由所有客户端共享，不能因为程序正在为客户端提供服务而停止侦听传入数据包。即，对 generatemessagetoudp 的调用应该在另一个例程中执行。

以下是对这些评论的修订版本。

添加 var 对等映射[string]peer 以将远程地址与上下文进行匹配。类型 peer 定义为 struct {stop func();since time.time}。收到启动消息后，peer 将被添加到带有派生上下文 pctx, pcancel := context.withcancel(ctx) 的 map。然后，新客户端在不同的例程 gogeneratemessagetoudp(pctx, udpserver, addr) 中提供服务，该例程绑定到新创建的上下文和服务器套接字。收到停止消息后，程序执行查找 peer, ok := peers[addr.string()]，然后取消关联的对等上下文 peer.stop()； delete(peers, addr.string()) 并忘记了对等点。

package main

import (
    "context"
    "fmt"
    "math/rand"
    "net"
    "time"
)

func generatemessagetoudp(ctx context.context, conn *net.udpconn, addr *net.udpaddr) {
    fmt.println("generating message to udp client", addr)
    go func() {
        for i := 0; ; i++ {
            randomint := rand.intn(100)
            d := []byte(fmt.sprintf("%d", randomint))
            conn.writeto(d, addr)
            time.sleep(time.second * 1)
        }
    }()
    <-ctx.done()
    fmt.println("stopping writing to udp client", addr)
}

//var addr *net.udpaddr
//var conn *net.udpconn

func main() {
    fmt.println("hi this is a udp server")
    udpserver, err := net.listenudp("udp", &net.udpaddr{ip: net.ipv4(0, 0, 0, 0), port: 5010})
    if err != nil {
        fmt.println("error: ", err)
    }
    defer func(udpserver *net.udpconn) {
        err := udpserver.close()
        if err != nil {
            fmt.println("error in closing the udp connection: ", err)
        }
    }(udpserver)
    // create a buffer to read data into
    type peer struct {
        stop  func()
        since time.time
    }
    peers := map[string]peer{}
    buffer := make([]byte, 1024)
    ctx, cancel := context.withcancel(context.background())
    defer cancel()
    for {
        // read the incoming connection into the buffer
        n, addr, err := udpserver.readfromudp(buffer)
        if err != nil {
            fmt.println("error: ", err)
        }
        fmt.println("received ", string(buffer[0:n]), " from ", addr)
        if string(buffer[0:n]) == "stop" {
            fmt.println("stopped listening")
            peer, ok := peers[addr.string()]
            if !ok {
                continue
            }
            peer.stop()
            delete(peers, addr.string())
            continue
        } else if string(buffer[0:n]) == "start" {
            peer, ok := peers[addr.string()]
            if ok {
                continue
            }
            pctx, pcancel := context.withcancel(ctx)
            peer.stop = pcancel
            peer.since = time.now()
            peers[addr.string()] = peer
            // send a response back to the client
            _, err = udpserver.writetoudp([]byte("hi, i am a udp server"), addr)
            if err != nil {
                fmt.println("error: ", err)
            }
            // start a routine to generate messages to the client
            go generatemessagetoudp(pctx, udpserver, addr)
        } else if string(buffer[0:n]) == "ping" {
            peer, ok := peers[addr.string()]
            if !ok {
                continue
            }
            peer.since = time.now()
            peers[addr.string()] = peer
        } else {
            fmt.println("unknown command")
        }
        for addr, p := range peers {
            if time.since(p.since) > time.minute {
                fmt.println("peer timedout")
                p.stop()
                delete(peers, addr)
            }
        }
    }
}
-- go.mod --
module play.ground
-- client.go --
package main

import (
    "fmt"
    "log"
    "net"
    "time"
)

func main() {
    fmt.println("hello, i am a client")

    // create a new client
    localaddr, err := net.resolveudpaddr("udp", "127.0.0.1:5011")
    client3, err := net.dialudp("udp", localaddr, &net.udpaddr{ip: net.ipv4(127, 0, 0, 1), port: 5010})
    if err != nil {
        fmt.println(err)
        return
    }
    defer client3.close()
    var n int
    n, err = client3.write([]byte("start"))
    if err != nil {
        fmt.println(err)
        return
    }
    log.println(n)
    now := time.now()
    b := make([]byte, 2048)
    for time.since(now) < time.second*10 {
        n, addr, err := client3.readfrom(b)
        fmt.println(n, addr, err)
        if err != nil {
            fmt.println(err)
            continue
        }
        if addr.string() == "127.0.0.1:5010" {
            m := b[:n]
            fmt.println("message:", string(m))
        }
    }
    fmt.println("sending stop message")
    _, err = client3.write([]byte("stop"))
    if err != nil {
        fmt.println(err)
    }
}

在

go func() {
        for i := 0; ; i++ {
            RandomInt := rand.Intn(100)
            d := []byte(fmt.Sprintf("%d", RandomInt))
            conn.WriteTo(d, addr)
            time.Sleep(time.Second * 1)
        }
    }()

我将上下文通道上缺少的选择的写入作为练习留给读者，以确定例程是否应该退出。

好吧，我在服务器上做了一个简单的修改并添加了一个label 在创建上下文之前开始，当我取消上下文时，我添加了 goto 标签。这意味着当任务被取消时，它将再次创建上下文并开始执行其工作

理论要掌握，实操不能落！以上关于《简化 For 循环中的上下文》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！

版本声明

本文转载于：stackoverflow 如有侵犯，请联系study_golang@163.com删除