Go 不'；I don’我无法从频道接收信息 编辑：

在我添加了一小部分我正在使用的文件（7 GB）并尝试运行该程序后，我可以看到：

fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan receive]:
main.main()
    /media/developer/golang/manual/examples/sp/v2/sp.v2.go:71 +0x4a9
exit status 2

情况： 我是新手，如果我的问题很简单，我很抱歉

我正在尝试流式传输

xml

文件，拆分文档，然后在不同的GO例程中解析它们

我正在使用的XML文件示例：

<?xml version="1.0" encoding="UTF-8"?>
<osm version="0.6" generator="CGImap 0.0.2">
    <relation id="56688" user="kmvar" uid="56190" visible="true" version="28" changeset="6947637" timestamp="2011-01-12T14:23:49Z">
        <member type="node" ref="294942404" role=""/>
        <member type="node" ref="364933006" role=""/>
        <tag k="name" v="Küstenbus Linie 123"/>
        <tag k="network" v="VVW"/>
        <tag k="route" v="bus"/>
        <tag k="type" v="route"/>
    </relation>
    <relation id="98367" user="jdifh" uid="92834" visible="true" version="28" changeset="6947637" timestamp="2011-01-12T14:23:49Z">
        <member type="node" ref="294942404" role=""/>
        <member type="way" ref="4579143" role=""/>
        <member type="node" ref="249673494" role=""/>
        <tag k="name" v="Küstenbus Linie 123"/>
        <tag k="network" v="VVW"/>
        <tag k="operator" v="Regionalverkehr Küste"/>
        <tag k="ref" v="123"/>
    </relation>
    <relation id="72947" user="schsu" uid="92374" visible="true" version="28" changeset="6947637" timestamp="2011-01-12T14:23:49Z">
        <member type="node" ref="294942404" role=""/>
        <tag k="name" v="Küstenbus Linie 123"/>
        <tag k="type" v="route"/>
    </relation>
    <relation id="93742" user="doiff" uid="61731" visible="true" version="28" changeset="6947637" timestamp="2011-01-12T14:23:49Z">
        <member type="node" ref="294942404" role=""/>
        <member type="node" ref="364933006" role=""/>
        <tag k="route" v="bus"/>
        <tag k="type" v="route"/>
    </relation>
</osm>

我有一段代码：

package main

import (
  "encoding/xml"
  "bufio"
  "fmt"
  "os"
  "io"
)

type RS struct {
  I string `xml:"id,attr"`
  M []struct {
    I string `xml:"ref,attr"`
    T string `xml:"type,attr"`
    R string `xml:"role,attr"`
  } `xml:"member"`
  T []struct {
    K string `xml:"k,attr"`
    V string `xml:"v,attr"`
  } `xml:"tag"`
}

func main() {
  p1D, err := os.Open("/media/developer/Transcend/osm/xml/relations.xml")

  if err != nil {
    fmt.Println(err)
    os.Exit(1)
  }

  defer p1D.Close()

  reader := bufio.NewReader(p1D)

  var count int32
  var element string

  channel := make(chan RS) // channel

  for {
    p2Rc, err := reader.ReadSlice('\n')
    if err != nil {
      if err == io.EOF {
        break
      } else {
        fmt.Println(err)
        os.Exit(1)
      }
    }

    var p2Rs = string(p2Rc)

    if p2Rc[2] == 114 {
      count++

      if (count != 1) {
        go parseRelation(element, channel)
      }

      element = ""
      element += p2Rs
    } else {
      element += p2Rs
    }
  }

  for i := 0; i < 5973974; i++ {
    fmt.Println(<- channel)
  }
}

func parseRelation(p1E string, channel chan RS) {
  var rs RS
  xml.Unmarshal([]byte(p1E), &rs)

  channel <- rs
}

主程序包
进口(
“编码/xml”
“布菲奥”
“fmt”
“操作系统”
“io”
)
类型RS结构{
I字符串`xml:“id，attr”`
M[]结构{
I字符串`xml:“ref，attr”`
T string`xml:“类型，属性”`
R字符串`xml:“角色，属性”`
}`xml:“成员”`
T[]结构{
K字符串`xml:“K，attr”`
V字符串`xml:“V，attr”`
}`xml:“标记”`
}
func main（）{
p1D，err:=os.Open（“/media/developer/extend/osm/xml/relations.xml”）
如果错误！=零{
fmt.Println（错误）
操作系统退出（1）
}
延迟p1D.Close（）
读卡器：=bufio.NewReader（p1D）
变量计数int32
变量元素字符串
通道：=制造（通道）//通道
为了{
p2Rc，错误：=reader.ReadSlice（'\n'）
如果错误！=零{
如果err==io.EOF{
打破
}否则{
fmt.Println（错误）
操作系统退出（1）
}
}
变量p2Rs=字符串（p2Rc）
如果p2Rc[2]==114{
计数++
如果（计数！=1）{
go parseRelation（元素、通道）
}
element=“”
元素+=p2Rs
}否则{
元素+=p2Rs
}
}
对于i:=0；i<5973974；i++{
fmt.Println（我不知道这是否对您有帮助，但您的条件是，
如果p2Rc[2]==114
从未得到满足，那么您可以继续收听一个从未收到输入的频道。此外，还有更好的收听频道的方法，
选择
，例如，这里有一个例子

我想这里的主要问题是，这（代码）意味着什么？以及上述情况属于该过程的哪一部分？如果这一点很清楚，我可以用更好的回答进行更新。
我不知道这是否对您有帮助，但您的情况，
如果p2Rc[2]==114
永远不会满足，然后您继续收听一个频道。该频道从未收到输入。此外，还有更好的收听频道的方法，
选择
例如，下面是一个示例

我想这里的主要问题是这是什么（代码）这意味着要做什么？上面提到的条件在哪里属于这个过程？如果这是清楚的，我可以更新一个更好的响应。
首先，让我们解决这个问题：你不能逐行解析XML。你很幸运，你的文件恰好每行有一个标记，但这不是理所当然的。你必须解析整个XML文档

通过逐行处理，您试图将
和
推入为
设计的结构中。相反，请使用并让它为您处理文件

package main

import (
    "encoding/xml"
    "fmt"
    "os"
    "log"
)

type Osm struct {
    XMLName     xml.Name    `xml:"osm"`
    Relations   []Relation  `xml:"relation"`
}
type Relation struct {
    XMLName     xml.Name    `xml:"relation"`
    ID          string      `xml:"id,attr"`
    User        string      `xml:"user,attr"`
    Uid         string      `xml:"uid,attr"`
    Members     []Member    `xml:"member"`
    Tags        []Tag       `xml:"tag"`
}
type Member struct {
    XMLName     xml.Name    `xml:"member"`
    Ref         string      `xml:"ref,attr"`
    Type        string      `xml:"type,attr"`
    Role        string      `xml:"role,attr"`
}
type Tag struct {
    XMLName     xml.Name    `xml:"tag"`
    Key         string      `xml:"k,attr"`
    Value       string      `xml:"v,attr"`
}

func main() {
    reader, err := os.Open("test.xml")
    if err != nil {
        log.Fatal(err)
    }
    defer reader.Close()

    decoder := xml.NewDecoder(reader)

    osm := &Osm{}
    err = decoder.Decode(&osm)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(osm)
}

Osm
和其他结构类似于您期望的XML模式。
decoder.Decode（&Osm）
应用该模式

如果您只想提取XML的一部分

答案的其余部分将只涉及通道和goroutine的使用，XML部分将被删除


如果添加一些调试语句，您会发现从未调用
parseRelation
，这意味着
通道
为空且
fmt.Println（首先，让我们解决这个问题：您不能逐行解析XML。幸运的是，您的文件恰好每行有一个标记，但这不是理所当然的。您必须解析整个XML文档

通过逐行处理，您试图将
和
推入为
设计的结构中。相反，请使用并让它为您处理文件

package main

import (
    "encoding/xml"
    "fmt"
    "os"
    "log"
)

type Osm struct {
    XMLName     xml.Name    `xml:"osm"`
    Relations   []Relation  `xml:"relation"`
}
type Relation struct {
    XMLName     xml.Name    `xml:"relation"`
    ID          string      `xml:"id,attr"`
    User        string      `xml:"user,attr"`
    Uid         string      `xml:"uid,attr"`
    Members     []Member    `xml:"member"`
    Tags        []Tag       `xml:"tag"`
}
type Member struct {
    XMLName     xml.Name    `xml:"member"`
    Ref         string      `xml:"ref,attr"`
    Type        string      `xml:"type,attr"`
    Role        string      `xml:"role,attr"`
}
type Tag struct {
    XMLName     xml.Name    `xml:"tag"`
    Key         string      `xml:"k,attr"`
    Value       string      `xml:"v,attr"`
}

func main() {
    reader, err := os.Open("test.xml")
    if err != nil {
        log.Fatal(err)
    }
    defer reader.Close()

    decoder := xml.NewDecoder(reader)

    osm := &Osm{}
    err = decoder.Decode(&osm)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(osm)
}

Osm
和其他结构类似于您期望的XML模式。
decoder.Decode（&Osm）
应用该模式

如果您只想提取XML的一部分

答案的其余部分将只涉及通道和goroutine的使用，XML部分将被删除


如果添加一些调试语句，您会发现从未调用
parseRelation
，这意味着
通道
为空且
fmt.Println（电话号码5973974从哪里来？是某人的电话号码吗？@DietrichEpp这只是文件中
xml
文档的数量。请发布一个您正在使用的xml示例，它将帮助我们检查数据是否被解密。@Himanshu刚刚添加了xml文件的示例。现在，当我用小的大量的xml文件我可以看到错误
致命错误：所有的goroutines都处于休眠状态-死锁！
号码5973974来自哪里？是某人的电话号码吗？@DietrichEpp这只是文件中
xml
文档的数量。请发布一个您正在使用的xml示例，它将帮助我们检查数据是否未被加密或者没有。@Himanshu刚刚添加了xml文件的示例。现在，当我使用xml文件的小示例运行程序时，我可以看到错误
致命错误：所有goroutine都处于休眠状态-死锁！
我想你是想添加
延迟wg.Done（）
//Element reader
中的
，除了那篇精彩的回复之外，谢谢！我想你是想在
//Element reader
中添加
defer wg.Done（）
，除了那篇精彩的回复之外，谢谢！
for i := 0; i < 5973974; i++ {
  fmt.Println(<- channel)
}

for thing := range channel {
    fmt.Println(thing)
}

func main() {
    reader, err := os.Open("test.xml")
    if err != nil {
        log.Fatal(err)
    }
    defer reader.Close()

    // Use the simpler bufio.Scanner
    scanner := bufio.NewScanner(reader)

    // A buffered channel for input
    lines := make(chan string, 10)

    // Work on the lines
    go func() {
        for line := range lines {
            fmt.Println(line)
        }
    }()

    // Read lines into the channel
    for scanner.Scan() {
        lines <- scanner.Text()
    }
    if err := scanner.Err(); err != nil {
        log.Fatal(err)
    }

    // When main exits, channels gracefully close.
}

// A buffered channel for input
lines := make(chan string, 10)

// Work on the lines
go func() {
    for line := range lines {
        fmt.Println(line)
    }
}()

// Read lines into the channel
go func() {
    for scanner.Scan() {
        lines <- scanner.Text()
    }
    if err := scanner.Err(); err != nil {
        log.Fatal(err)
    }
}()

// A buffered channel for input
lines := make(chan string, 10)

// A channel for main to wait for
done := make(chan bool, 1)

// Work on the lines
go func() {
    for line := range lines {
        fmt.Println(line)
    }

    // Indicate the worker is done
    done <- true
}()

// Read lines into the channel
go func() {
    // Explicitly close `lines` when we're done so the workers can finish
    defer close(lines)

    for scanner.Scan() {
        lines <- scanner.Text()
    }
    if err := scanner.Err(); err != nil {
        log.Fatal(err)
    }
}()

// main will wait until there's something to read from `done`
<-done

// A buffered channel for input
lines := make(chan string, 10)

var wg sync.WaitGroup

// Note that there is one more thing to wait for
wg.Add(1)
go func() {
    // Tell the WaitGroup we're done
    defer wg.Done()

    for line := range lines {
        fmt.Println(line)
    }
}()

// Read lines into the channel
go func() {
    defer close(lines)

    for scanner.Scan() {
        lines <- scanner.Text()
    }
    if err := scanner.Err(); err != nil {
        log.Fatal(err)
    }
}()

// Wait until everything in the WaitGroup is done
wg.Wait()

// A buffered channel for input
lines := make(chan []byte, 10)
elements := make(chan *RS)

var wg sync.WaitGroup

// Worker goroutine, turn lines into RS structs
wg.Add(1)
go func() {
    defer wg.Done()
    defer close(elements)

    for line := range lines {
        if line[2] == 32 {
            fmt.Println("Begin")
            fmt.Println(string(line))
            fmt.Println("End")

            rs := &RS{}
            xml.Unmarshal(line, &rs)
            elements <- rs
        }
    }
}()

// File reader
go func() {
    defer close(lines)

    for scanner.Scan() {
        lines <- scanner.Bytes()
    }
    if err := scanner.Err(); err != nil {
        log.Fatal(err)
    }
}()

// Element reader
wg.Add(1)
go func() {
    defer wg.Done()

    for element := range elements {
        fmt.Println(element)
    }
}()

wg.Wait()