教程集 > Golang编程 > golang教程 > 正文 golang从channel读数据的各种情况

golang从channel读数据的各种情况

发布时间：2022-01-22 编辑：jiaochengji.com

教程集为您提供golang从channel读数据的各种情况等资源，欢迎您收藏本站，我们将为您提供最新的golang从channel读数据的各种情况资源

<h3>文章目录</h3> <ul><li><ul><li><ul><li>用var定义channel且不make</li><li>用var定义channel且make</li><li>直给写操作加for</li><li>直给读操作加for</li><li>读写都加for</li><li>读channel的第二个返回值</li><li>关闭channel继续读</li><li>写完然后关闭channel再开始读</li><li>加个select</li><li>channel未及时关闭</li><li>总结</li></ul></li></ul></li></ul>

<h3>用var定义channel且不make</h3> <pre><code class="lang-go hljs">wg := sync.WaitGroup{} var ch chan string read := func() { fmt.Println("reading") s := <-ch fmt.Println("read:", s) wg.Done() } write := func() { fmt.Println("writing") s := "t" ch <- s fmt.Println("write:", s) wg.Done() } wg.Add(2) go read() go write() fmt.Println("waiting") wg.Wait() </code></pre>

输出：

<pre><code>waiting writing reading fatal error: all goroutines are asleep - deadlock! </code></pre>

这种情况并不是报错空指针，而是死锁。加上make看看

<h3>用var定义channel且make</h3> <pre><code class="lang-go hljs">wg := sync.WaitGroup{} var ch = make(chan string) read := func() { fmt.Println("reading") s := <-ch fmt.Println("read:", s) wg.Done() } write := func() { fmt.Println("writing") s := "t" ch <- s fmt.Println("write:", s) wg.Done() } wg.Add(2) go read() go write() </code></pre>

输出

<pre><code>waiting writing reading read: t write: t </code></pre>

这种情况没什么毛病，之所以先输出的read，是因为IO机制。下面给写加上for

<h3>直给写操作加for</h3> <pre><code class="lang-go hljs">wg := sync.WaitGroup{} var ch = make(chan string) read := func() { fmt.Println("reading") s := <-ch fmt.Println("read:", s) wg.Done() } write := func() { for { fmt.Println("writing") s := "t" ch <- s fmt.Println("write:", s) } wg.Done() } wg.Add(2) go read() go write() fmt.Println("waiting") wg.Wait() fmt.Println("finish") </code></pre>

输出

<pre><code>waiting reading writing write: t writing read: t fatal error: all goroutines are asleep - deadlock! </code></pre>

报错说所有的协程都睡着，意思就是runtime发现没有能拿来调度的协程了，报错退出。如果是在大项目中，这里则会阻塞，runtime会调度其他可运行的协程。下面把for移到读操作上。

<h3>直给读操作加for</h3> <pre><code class="lang-go hljs">wg := sync.WaitGroup{} var ch = make(chan string) read := func() { for { fmt.Println("reading") s := <-ch fmt.Println("read:", s) } wg.Done() } write := func() { fmt.Println("writing") s := "t" ch <- s fmt.Println("write:", s) wg.Done() } wg.Add(2) go read() go write() fmt.Println("waiting") wg.Wait() fmt.Println("finish") </code></pre>

输出

<pre><code>waiting reading writing write: t read: t reading fatal error: all goroutines are asleep - deadlock! </code></pre>

跟上面现象基本一样，不再赘述，然后给俩操作都加上for

<h3>读写都加for</h3> <pre><code class="lang-go hljs">wg := sync.WaitGroup{} var ch = make(chan string) read := func() { for { fmt.Println("reading") s := <-ch fmt.Println("read:", s) } wg.Done() } write := func() { for { fmt.Println("writing") s := "t" ch <- s fmt.Println("write:", s) } wg.Done() } wg.Add(2) go read() go write() fmt.Println("waiting") wg.Wait() fmt.Println("finish") </code></pre>

输出

<pre><code>waiting writing reading read: t write: t writing reading read: t reading write: t writing write: t writing ... </code></pre>

结果当然就是死循环了，这个很好理解。接下来才是本文的重点：读数据的第二个参数。我们先保持其他的都不动，在读的时候接收第二个返回值。

<h3>读channel的第二个返回值</h3> <pre><code class="lang-go hljs">wg := sync.WaitGroup{} var ch = make(chan string) read := func() { for { fmt.Println("reading") s, ok := <-ch fmt.Println("read:", s, ok) } wg.Done() } write := func() { for { fmt.Println("writing") s := "t" ch <- s fmt.Println("write:", s) } wg.Done() } wg.Add(2) go read() go write() fmt.Println("waiting") wg.Wait() fmt.Println("finish") </code></pre>

输出

<pre><code>waiting writing reading read: t true reading write: t writing write: t writing read: t true reading read: t true reading write: t ... </code></pre>

可以看出来，这第二个返回值是个bool类型，目前全都是true。那么什么时候会是false呢，把channel关上试试。为了更直观，把字符串的长度一起输出

<h3>关闭channel继续读</h3> <pre><code class="lang-go hljs">wg := sync.WaitGroup{} var ch = make(chan string) read := func() { for { fmt.Println("reading") s, ok := <-ch fmt.Println("read:", len(s), s, ok) } wg.Done() } write := func() { for i := 0; i < 5; i { fmt.Println("writing") s := "t" ch <- s fmt.Println("write:", s) } wg.Done() close(ch) } wg.Add(2) go read() go write() fmt.Println("waiting") wg.Wait() fmt.Println("finish") </code></pre>

输出

<pre><code>waiting writing reading read: 1 t true reading write: t writing write: t writing read: 1 t true reading read: 1 t true reading write: t writing write: t writing read: 1 t true reading read: 1 t true reading write: t read: 0 false reading read: 0 false reading read: 0 false ... </code></pre>

接下来就是很规律的死循环了。这样是不是可以猜测，从已经close的channle读数据，会读到该数据类型的零值，且第二个返回值为false？再试试给channel加个buffer，先写完关上再开始读

<h3>写完然后关闭channel再开始读</h3> <pre><code class="lang-go hljs">wg := sync.WaitGroup{} var ch = make(chan string, 5) read := func() { for { fmt.Println("reading") s, ok := <-ch fmt.Println("read:", len(s), s, ok) } wg.Done() } write := func() { for i := 0; i < 5; i { fmt.Println("writing") s := "t" ch <- s fmt.Println("write:", s) } wg.Done() close(ch) fmt.Println("closed") } wg.Add(2) write() go read() fmt.Println("waiting") wg.Wait() fmt.Println("finish") </code></pre>

输出

<pre><code class="lang-go hljs">writing write: t writing write: t writing write: t writing write: t writing write: t closed waiting reading read: 1 t true reading read: 1 t true reading read: 1 t true reading read: 1 t true reading read: 1 t true reading read: 0 false reading read: 0 false reading read: 0 false ... </code></pre>

我们把写操作前的<code>go</code>关键字去了，并且在关闭channel之后加了log。可以很清晰的看到，先往channel里写了5次，然后close了，之后才有wait及read的log。并且前5个ok是true，后面循环输出false。现在我们可以得出结论当channel关闭且数据都读完了，再读数据会读到该数据类型的零值，且第二个返回值为false。下面再套上select

<h3>加个select</h3> <pre><code class="lang-go hljs">wg := sync.WaitGroup{} var ch = make(chan string, 5) read := func() { for { fmt.Println("reading") select { case s, ok := <-ch: fmt.Println("read:", len(s), s, ok) } } wg.Done() } write := func() { for i := 0; i < 5; i { fmt.Println("writing") s := "t" ch <- s fmt.Println("write:", s) } wg.Done() close(ch) fmt.Println("closed") } wg.Add(2) write() go read() fmt.Println("waiting") wg.Wait() fmt.Println("finish") </code></pre>

输出

<pre><code>writing write: t writing write: t writing write: t writing write: t writing write: t closed waiting reading read: 1 t true reading read: 1 t true reading read: 1 t true reading read: 1 t true reading read: 1 t true reading read: 0 false reading read: 0 false reading read: 0 false ... </code></pre>

很明显跟上面现象一致，如果忘了关闭channel呢？

<h3>channel未及时关闭</h3> <pre><code class="lang-go hljs">wg := sync.WaitGroup{} var ch = make(chan string, 5) read := func() { for { fmt.Println("reading") select { case s, ok := <-ch: fmt.Println("read:", len(s), s, ok) } } wg.Done() } write := func() { for i := 0; i < 5; i { fmt.Println("writing") s := "t" ch <- s fmt.Println("write:", s) } wg.Done() //close(ch) //fmt.Println("closed") } wg.Add(2) write() go read() fmt.Println("waiting") wg.Wait() fmt.Println("finish") </code></pre>

输出

<pre><code>writing write: t writing write: t writing write: t writing write: t writing write: t waiting reading read: 1 t true reading read: 1 t true reading read: 1 t true reading read: 1 t true reading read: 1 t true reading fatal error: all goroutines are asleep - deadlock! </code></pre>

又睡着了，然后报错。跟上面情况一样，如果是在大项目中，runtime会调度其他可运行的协程。最后来总结一下怎么操作才算优(sao)雅(qi)。

<h3>总结</h3> <ul><li>对写的一方来说，一定记着及时关闭channel，避免出现协程泄露。虽然它占得资源少，省点电不香么。</li><li>对读的一方来说，除非十分确定数据的个数，最好是用for来读数据，省的在“管儿”里有“野数据”造成内存泄露。同时根据第二个返回值的真假来控制for循环，避免出现“无效工作量”</li></ul>

<blockquote class="layui-elem-quote" style="width: 100%;overflow:hidden"> 作者： xmh19936688
链接： https://blog.csdn.net/xmh19936688/article/details/106280737
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
</blockquote>

到此这篇关于“golang从channel读数据的各种情况”的文章就介绍到这了,更多文章或继续浏览下面的相关文章，希望大家以后多多支持JQ教程网！

您可能感兴趣的文章：
golang channel的使用以及调度原理
 【文末有惊喜！】一文读懂golang channel
图解 Go 并发编程
 golang知识点
 Go并发编程——channel
图解Go的channel底层原理
 Golang 中的 Goroutine 调度原理与 Chanel 通信
 协程调度时机二：Channel读写
 go语言并发编程
 golang goroutine 通知_深入golang之---goroutine并发控制与通信

上一篇：深入理解go-channel和select的原理下一篇：Linux环境使用nginx和supervisor部署beego

[关闭]

golang从channel读数据的各种情况

最近更新

浏览排行