go语言管道(channel)

已于 2022-04-23 16:56:36 修改
阅读量4.1k 收藏 12
点赞数 4
分类专栏： golang 文章标签： go channel
于 2022-04-17 23:40:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57023347/article/details/124238503
版权

前言

        channel式go语言协程中数据通信的双向通道。但是在实际应用中，为了代码的简单和易懂，一般使用的channel是单向的。

使用

1. channel的定义和收发数据

package channel


func main(){
	//var c chan int   c的默认值位nil，一般不使用 
	c := make(chan int)
	c <- 1 //发数据
	n := <-c //收数据 
}

但是上面收发数据的写法是错误的，因为一个协程往管道里发送数据，必须要有一个协程来接受数据，否则会造成死锁。(协程往管道发送数据和从管道接受数据为了防止数据紊乱，会加上锁)

注意：

        协程从管道里接收数据时，当没有收到数据时，会一直等待。这样效率不是很高，使用select，可以实现同步的功能，后面有介绍。

正确写法：

package main

import (
	"fmt"
	"time"
)

func chanDemo() {
	c := make(chan int)
	go func() {
		for {
			n := <-c //收数据
			fmt.Println(n)
		}
	}()
	c <- 1 //发数据
	c <- 2

	//防止数据还没有在协程里打印，main函数退出
	time.Sleep(time.Millisecond)
}

func main() {
	chanDemo()
}

2. channel作为参数

        channel在go语言里作为一等公民，可以作为参数和返回值

package main

import (
	"fmt"
	"time"
)

func worker(c chan int) {
	for {
		n := <-c
		fmt.Println(n)
	}
}

func chanDemo() {
	var channels [10]chan int
	for i := 0; i < 10; i++ {
		channels[i] = make(chan int)
		go worker(channels[i])
	}

	for i := 0; i < 10; i++ {
		channels[i] <- i
	}

	//防止数据还没有在协程里打印，main函数退出
	time.Sleep(time.Second)
}

func main() {
	chanDemo()
}

3. channel做返回值

package main

import (
	"fmt"
	"time"
)

func worker(id int, c chan int) {
	for {
		fmt.Printf("worker %d, reseived %d\n", id, <-c)
	}
}

//返回一个channel
func createWoker(id int) chan int {
	c := make(chan int)
	go worker(id, c)
	return c
}

func chanDemo() {
	var channels [10]chan int
	for i := 0; i < 10; i++ {
		channels[i] = createWoker(i)
	}

	for i := 0; i < 10; i++ {
		channels[i] <- i
	}

	//防止数据还没有在协程里打印，main函数退出
	time.Sleep(time.Second)
}

func main() {
	chanDemo()
}

但是在实际应用中，当项目很复杂时，createWoker返回的channel需要告诉调用方，返回的channel该如何使用，我们可以在返回的channel加上限制。如下：

//返回一个channel，只能被接收数据
func createWoker(id int) <-chan int {
	c := make(chan int)
	go worker(id, c)
	return c
}

//返回一个channel，只能发送数据
func createWoker(id int) chan<- int {
	c := make(chan int)
	go worker(id, c)
	return c
}

Channel缓存

        上面说，当一个协程向channel发送数据时，必须要有一个协程来接收数据，否则会造成死锁。

package main

import (
	"fmt"
	"time"
)

func channel() {
	c := make(chan int)
	c <- 1
}

func main() {
	channel()
}

         但是我们可以建立一个channel缓存，先将数据放到缓存中，需要时再使用，即使，没有协程接收也不会造成死锁。

package main

import (
	"fmt"
	"time"
)

func bufferedChannel() {
	//channel缓存
	c := make(chan int, 3)

	c <- 1
	c <- 2
	c <- 3
}

func main() {
	bufferedChannel()
}

 关闭channel，并不是销毁

        当发送完数据，channel是可以被关闭的。

package main

import (
	"fmt"
	"time"
)

func worker(id int, c chan int) {
	for {
		fmt.Printf("worker %d, reseived %d\n", id, <-c)
	}
}

func closeChannel() {
	c := make(chan int)
	go worker(0, c)
	c <- 1
	c <- 2
	c <- 3
	close(c)

	time.Sleep(time.Millisecond)
}

func main() {
	bufferedChannel()
}

        当发送方关闭channel后，接收方还是可以从channel接收到数据，接收到的数据是后面类型的默认值。

         但是，这样是不合理的，接收方同样可以判断发送方是否关闭了channel

        有两种方法可以判断发送方是否关闭了channel

方法一：利用判断。

package main

import (
	"fmt"
	"time"
)

func worker(id int, c chan int) {
	for {
		n, ok := <-c
		//说明发送方关闭了channel
		if !ok {
			break
		}
		fmt.Printf("worker %d, reseived %d\n", id, n)
	}
}

func closeChannel() {
	c := make(chan int)
	go worker(0, c)
	c <- 1
	c <- 2
	c <- 3
	close(c)

	time.Sleep(time.Millisecond)
}

func main() {
	closeChannel()
}

 方法二：利用range，当发送方关闭了channel，range也会自动退出。

package main

import (
	"fmt"
	"time"
)

func worker(id int, c chan int) {
	for n := range c {
		fmt.Printf("worker %d, reseived %d\n", id, n)
	}
}

func closeChannel() {
	c := make(chan int)
	go worker(0, c)
	c <- 1
	c <- 2
	c <- 3
	close(c)

	time.Sleep(time.Millisecond)
}

func main() {
	closeChannel()
}

使用channel等待任务结束

        上面在每一个函数中，我们都加了一段延时，来等待协程的结束。但是，这种做法很不好。

        处理一般是，当协程任务结束，通知外层任务结束。一种思想，通过通信来共享内存，而不是通过共享内存来通信。延时就不需要了。

方法一：用一个channel来通知外层

package main

import (
	"fmt"
)

type worker struct {
	in   chan int
	done chan bool
}

func doWorker(id int, in chan int, done chan bool) {
	for n := range in {
		fmt.Printf("worker %d, reseived %d\n", id, n)
		//说明任务结束
		done <- true
	}
}

//返回一个channel
func createWoker(id int) worker {
	w := worker{
		in:   make(chan int),
		done: make(chan bool),
	}
	go doWorker(id, w.in, w.done)
	return w
}

func chanDemo() {
	var channels [10]worker
	for i := 0; i < 10; i++ {
		channels[i] = createWoker(i)
	}

	for i := 0; i < 10; i++ {
		channels[i].in <- i
		//等到任务结束
		<-channels[i].done
	}

}

func main() {
	chanDemo()
}

注意：

//等到任务结束
		<-channels[i].done

channel发送和接收数据时阻塞式的，必须要有人接收和发送数据，不然会一直等待。

如果在doWorker中，不返回任务结束的消息，会造成死锁。

package main

import (
	"fmt"
)

type worker struct {
	in   chan int
	done chan bool
}

func doWorker(id int, in chan int, done chan bool) {
	for n := range in {
		fmt.Printf("worker %d, reseived %d\n", id, n)
		// //说明任务结束
		// done <- true
	}
}

//返回一个channel
func createWoker(id int) worker {
	w := worker{
		in:   make(chan int),
		done: make(chan bool),
	}
	go doWorker(id, w.in, w.done)
	return w
}

func chanDemo() {
	var channels [10]worker
	for i := 0; i < 10; i++ {
		channels[i] = createWoker(i)
	}

	for i := 0; i < 10; i++ {
		channels[i].in <- i
		//等到任务结束
		<-channels[i].done
	}

}

func main() {
	chanDemo()
}

 但是，上面正确的情况打印是顺序打印的，没有体现并行的好处。这是因为发送数据时，是发一个数据，等一个数据。我们需要做到，将数据全部发出去，再进行全部的等待。

 

package main

import (
	"fmt"
)

type worker struct {
	in   chan int
	done chan bool
}

func doWorker(id int, in chan int, done chan bool) {
	for n := range in {
		fmt.Printf("worker %d, reseived %d\n", id, n)
		// //说明任务结束
		done <- true
	}
}

//返回一个channel
func createWoker(id int) worker {
	w := worker{
		in:   make(chan int),
		done: make(chan bool),
	}
	go doWorker(id, w.in, w.done)
	return w
}

func chanDemo() {
	var channels [10]worker
	for i := 0; i < 10; i++ {
		channels[i] = createWoker(i)
	}

	//发送一次
	for i, worker := range channels {
		worker.in <- i
	}
	//发送第二次
	for i, worker := range channels {
		worker.in <- i * 10
	}

	//等待任务结束
	for _, worker := range channels {
		//发送了两次，接收两次
		<-worker.done
		<-worker.done
	}

}

func main() {
	chanDemo()
}

但是上面会造成死锁，因为，发送第一次数据的时候，在协程中，往done中发送了数据，没有接收，一直在done<-true等待，第二次往in中再发送数据，没有接收，造成死锁。

 解决：

1. 我们可以在在协程里再开一个协程，专门往done中发送数据，那么从in中接收数据的协程就不会阻塞了。

package main

import (
	"fmt"
)

type worker struct {
	in   chan int
	done chan bool
}

func doWorker(id int, in chan int, done chan bool) {
	for n := range in {
		fmt.Printf("worker %d, reseived %d\n", id, n)
		// //说明任务结束
		go func() {
			done <- true
		}()
	}
}

//返回一个channel
func createWoker(id int) worker {
	w := worker{
		in:   make(chan int),
		done: make(chan bool),
	}
	go doWorker(id, w.in, w.done)
	return w
}

func chanDemo() {
	var channels [10]worker
	for i := 0; i < 10; i++ {
		channels[i] = createWoker(i)
	}

	//发送一次
	for i, worker := range channels {
		worker.in <- i
	}
	//发送第二次
	for i, worker := range channels {
		worker.in <- i * 10
	}

	//等待任务结束
	for _, worker := range channels {
		//发送了两次，接收两次
		<-worker.done
		<-worker.done
	}

}

func main() {
	chanDemo()
}

 解决2：使用sync官方库的waitgroup

package main

import (
	"fmt"
	"sync"
)

type worker struct {
	in chan int
	wg *sync.WaitGroup
}

func doWorker(id int, in chan int, wg *sync.WaitGroup) {
	for n := range in {
		fmt.Printf("worker %d, reseived %d\n", id, n)

		//任务做完
		wg.Done()
	}
}

//返回一个channel
func createWoker(id int, wg *sync.WaitGroup) worker {
	w := worker{
		in: make(chan int),
		wg: wg,
	}
	go doWorker(id, w.in, w.wg)
	return w
}

func chanDemo() {
	var wg sync.WaitGroup

	var channels [10]worker
	for i := 0; i < 10; i++ {
		channels[i] = createWoker(i, &wg)
	}

	//增加20个任务进行等待，总共有20个任务
	wg.Add(20)
	//发送一次
	for i, worker := range channels {
		worker.in <- i
	}
	//发送第二次
	for i, worker := range channels {
		worker.in <- i * 10
	}

	//等待任务结束
	wg.Wait()
}

func main() {
	chanDemo()
}

 

两片空白
关注
  • 4
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
GO语言小锤硬磕.二十二 管道（channel）
arethusa69的专栏
04-19 365
只写管道var mych chan
Golang笔记——channel（管道）
weixin_44023658的博客
08-23 557
推荐首先阅读：Golang笔记——goroutine（协程） 为什么需要 channel 前面使用全局变量加锁同步来解决 goroutine 的通讯，但不完美 主线程在等待所有 goroutine 全部完成的时间很难确定，我们这里设置 10 秒，仅仅是估算。 如果主线程休眠时间长了，会加长等待时间，如果等待时间短了，可能还有 goroutine 处于工作 状态，这时也会随主线程的退出而销毁 通过全局变量加锁同步来实现通讯，也并不利用多个协程对全局变量的读写操作。 上面种种分析都在呼唤一个新的通讯机制-ch
Go中的管道（channel）
最新发布
shinamshiro的博客
04-28 594
（1）管道本质就是一个数据结构-队列（2）数据是先进先出（3）自身线程安全，多协程访问时，不需要加锁，channel本身就是线程安全的（4）管道有类型的，一个string的管道只能存放string类型数据var 变量名 chan 数据类型PS1：chan管道关键字PS2：数据类型指的是管道的类型，里面放入数据的类型，管道是有类型的，int类型的管道只能写入整数intPS3：管道是引用类型，必须初始化才能写入数据，即make后才能使用import("fmt"
golang语言中的channel语法
m0_51530927的博客
04-30 2134
golang语言中的channel语法有缓冲无缓冲，单向双向，newtimer，time。aftertimer.Stop，select上述语法的容量应该大于0，以便通道具有缓冲区。默认情况下，无缓冲通道的容量为0，因此在之前创建通道时省略了容量参数。如果不关闭的话，就会出现死锁。因为子 go 中都已放入暖冲后没有可用的供给 main go就会导致main go一直等待。单流程下一个 go 只能监控一个 channel 的状态，select 可以完成监控多个 channel 的状态。...
golang 学习（三十）管道(channel)介绍以及应用
wangyufeng43400141的专栏
07-15 1424
管道(channel)介绍以及应用 管道是 Golang 在语言级别上提供的 goroutine 间的通讯方式，我们可以使用 channel 在 多个 goroutine之间传递消息。如果说 goroutine 是 Go 程序并发的执行体，channel 就是它们 之间的连接。channel 是可以让一个goroutine 发送特定值到另一个 gorutine 的通信机制 Golang 的并发模型是 CSP（Comunicating Sequential Processes），提倡通过通信共享内 存而不是
golang开发:channel使用
飞翔码农的博客
09-26 1104
channel主要是用于多个goroutine之间通信 channel语法 channel是引用类型,需要实用make来创建channel,如下 make(chan Type, [buffer]) chan Type 通道的类型 buffer 是可选参数，代表通道缓冲区的大小(省略则代表无缓冲) 向channel里面写入数据使用 <- 符号 q := make(chan bool) q<-true 从channel里面读取数据也是使用 <- 符号，只不过写入的channel在右边，读.
Go语言的管道Channel用法实例
09-22
主要介绍了Go语言的管道Channel用法,实例分析了Go语言中管道的原理与使用技巧,具有一定参考借鉴价值,需要的朋友可以参考下
go语言channel实现多核并行化运行的方法
09-22
Go语言，也被称为Golang，是由Google开发的一种静态类型的、编译型的、并发型的、垃圾回收的、强类型的语言。它以其内置的并发原语而著名，这些原语使得编写能够充分利用多核处理器的程序变得简单。在Go语言中，`...
Go语言协程goroutine和管道channel教程.PDF
02-08
如此多的goroutine是Go运行时来调度的。Go运行时会把goroutine的任务分配给CPU去执行。**注意**，goroutine不是我们通常理解的线程，线程是操作系统调度的。 * Go编程里不需要自己在代码里写线程和协程，想让某个...
GO语言实战十 管道
01-20
【Go语言实战：管道Channel详解】 Go语言的并发特性是其设计的一大亮点，而管道（Channel）则是实现并发安全通信的关键工具。本篇将深入探讨管道的基本概念、使用方式以及其在goroutine间的同步作用。 ### 1. 通道...
go语言一些小例子例程
01-12
Go语言，也被称为Golang，是由Google开发的一种静态类型的、编译式的、并发型且具有垃圾回收功能的编程语言。它的设计目标是提高开发效率，同时保持程序的高性能和可靠性。Go语言以其简洁的语法、高效的并发模型以及...
详解go语言 make(chan int, 1) 和 make (chan int) 的区别
12-23
遇到golang channel 的一个问题：发现go 协程读取channel 数据 并没有按照预期进行协作执行。 经过查资料： 使用channel 操作不当导致,channel分 有缓冲区 和 无缓冲区 , 以下是两者的区别。 无缓冲区channel 用make(chan int) 创建的chan, 是无缓冲区的, send 数据到chan 时，在没有协程取出数据的情况下， 会阻塞当前协程的运行。ch <- 后面的代码就不会再运行，直到channel 的数据被接收，当前协程才会继续往下执行。 ch := make(chan int) // 创建无缓冲channel go func() {
go_ExternalOrdering:go 并发加管道channel实现外排序
04-29
在本文中，我们将深入探讨如何使用Go语言的并发特性，特别是管道channel，来实现外部排序（External Sorting）。外部排序是处理大数据集时的一种常见技术，它涉及到将数据分块加载到内存中，对这些块进行排序，然后...
Go语言生成素数的方法
12-25
本文实例讲述了Go语言生成素数的方法。分享给大家供大家参考。具体实现方法如下： 代码如下:package main // 生成2, 3, 4, … 到 channel ‘ch’中. func Generate(ch chan<- int) {  for i := 2; ; i++ {  ch...
管道channel 有无缓冲区的区别
01-20
在Go语言中，通道（Channel）是协程间通信的重要机制，它允许数据在不同的并发执行单元之间安全地传递。管道分为无缓冲通道和有缓冲通道，两者在使用上有着显著的区别。 无缓冲通道（无缓冲的Channel）就像是一个...
Go语言资料文档.zip
11-07
Go语言，又称Golang，是由Google在2009年推出的开源编程语言，旨在提高开发效率，特别是对于网络服务器、存储集群以及大型中央服务器等应用场景。Go语言的设计目标是结合C语言的执行效率和Python的易用性，提供一种...
Go语言管道
weixin_30662109的博客
04-22 104
Channel概念 Channel 是Go中的一个核心类型，你可以把它看成一个管道。Channel是引用类型，操作符是箭头<-。 Channel 是 CSP 模式的具体实现，用于多个 goroutine 通讯。其内部实现了同步，确保并发安全。 Channel 是线程安全的，先进先出，多个goroutine同时访问，不需要加锁，channel是有类型的，一个整数的channel只能存...
Go语言Channel深度理解
Simple子夜
07-12 226
Go语言采用的是并发模型是（CSP），提倡"通过通信共享内存"，而不是"通过共享内存实现通信"，**如果说goroutine是Go程序并发的执行体，那么channel则是它们之前的连接。channel是可以让一个goroutine发送一个特定的值到另外一个goroutine的通信机制**
【go语言之channel】
qq_37674060的博客
09-23 217
【go语言之channel】
浅谈 golang并发 GC
01-24
浅谈 golang并发 GC

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值