当前位置： > > > > 关闭结构内部的通道

关闭结构内部的通道

来源：stackoverflow
2024-04-25 11:36:29
0浏览
收藏

怎么入门Golang编程？需要学习哪些知识点？这是新手们刚接触编程时常见的问题；下面米云就来给大家整理分享一些知识点，希望能够给初学者一些帮助。本篇文章就来介绍《关闭结构内部的通道》，涉及到，有需要的可以收藏一下

问题内容

我一直在尝试查看有关关闭频道的现有帖子，但我似乎无法准确找到我正在寻找的内容。我的结构内部有两个通道。创建通道后，我尝试立即运行 defer close(channelname) ，但通道立即关闭，并且出现错误。如果我不处理关闭通道，代码运行正常，但不会正常关闭，我必须使用 ctrl z 暂停程序，因为它在使用 ctrl c 后仍在运行。以下是代码的重要部分：

type WebsocketClient struct {
    pubSocket  ws_client.Socket
    privSocket ws_client.Socket
    pubChan    chan interface{}
    privChan   chan interface{}
}

type KrakenClient struct {
    WebSocket WebsocketClient
    Testing   bool
}

func (client *KrakenClient) initChannels() {
    client.WebSocket.pubChan = make(chan interface{})
    client.WebSocket.privChan = make(chan interface{})

    //defer close(client.WebSocket.pubChan)
    //defer close(client.WebSocket.privChan)
}

func (client *KrakenClient) InitWebSocketClient(wg *sync.WaitGroup, testing bool) {
    client.initTesting(testing)
    client.initChannels()
    client.startWebSocketConnection(wg)
}

func (client *KrakenClient) PubDecoder(wg *sync.WaitGroup, ctx context.Context) {
    wg.Add(1)
    defer wg.Done()
    defer client.WebSocket.pubSocket.Close()

    if err := PubSocketGuard(client.WebSocket); err != nil { // guard clause checker. makes sure i'm actually using a public WebSocket
        panic(err)
    }

    var res interface{}

    ws_client.ReceiveLocker(&client.WebSocket.pubSocket)
    client.WebSocket.pubSocket.OnTextMessage = func(message string, socket ws_client.Socket) {
        res = ws_client.PubJsonDecoder(message, client.Testing)
        client.WebSocket.pubChan <- res
    }
    ws_client.ReceiveUnlocker(&client.WebSocket.pubSocket)

    <-ctx.Done()
    log.Println("closing public socket")
    return
}

func (client *KrakenClient) PubListen(wg *sync.WaitGroup, ctx context.Context, ohlcMap *types.OHLCVals) {
    wg.Add(1)
    defer wg.Done()

    for c := range client.WebSocket.pubChan {
        switch v := c.(type) {
        // More code here. Not important to the channel problem
    }
    <-ctx.Done()
}

func main() {
    var testing bool = true

    comms := make(chan os.Signal, 1)
    signal.Notify(comms, os.Interrupt, syscall.SIGTERM)
    ctx := context.Background()
    ctx, cancel := context.WithCancel(ctx)
    var wg sync.WaitGroup

    kraken := &kraken_client.KrakenClient{}
    kraken.InitWebSocketClient(&wg, testing)
    go kraken.PubDecoder(&wg, ctx)
    kraken.SubscribeToOHLC(&wg, []string{"BTC/USD"}, 5)

    ohlcMap := types.OHLCVals{}

    go kraken.PubListen(&wg, ctx, &ohlcMap)

    <-comms
    cancel()
    wg.Wait()

}

总之，struct krakenclient 有一个类型 websocketclient，它拥有 2 个 websocket 和 2 个通道。在 krakenclient 结构上调用 initwebsocketclient 函数会创建两个通道并连接到 ws 服务器。连接到服务器后，我开始解组所有响应并将这些响应发送到通道。然后，我订阅特定端点，并开始“监听”响应（实际上是遍历数据并将其添加到根据特定情况传递给监听函数的 ohlcmap 变量中）。我只是不明白应该在哪里关闭频道。我是否需要在 krakenclient 结构上创建一个 clos​​e 函数，该函数会在通道关闭时延迟？如果是这样，它会去哪里？感谢任何帮助！

正确答案

您必须在 main 函数中调用 defer，因为当您在 initchannels 函数中调用 defer 时，它会在创建后立即关闭您的通道。 延迟始终在函数（代码中的 initchannels）返回时执行。

您可以编写一个关闭函数来关闭通道并在主函数上调用它，如下所示：

func (client *KrakenClient) closeChannels() {
    close(client.WebSocket.pubChan)
    close(client.WebSocket.privChan)
}

func (client *KrakenClient) initChannels() {
    client.WebSocket.pubChan = make(chan interface{})
    client.WebSocket.privChan = make(chan interface{})
}

func main() {
    ...
    kraken.InitWebSocketClient(&wg, testing)
    defer kraken.closeChannels()
    ...
}

到这里，我们也就讲完了《关闭结构内部的通道》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注米云公众号，带你了解更多关于的知识点！