Channel

最新推荐文章于 2023-06-13 15:01:43 发布
最新推荐文章于 2023-06-13 15:01:43 发布
阅读量4.5k 收藏 1
点赞数
分类专栏： go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jinjia649472189/article/details/106999166
版权

goroutine之间的通信使用channel。数据传送是阻塞式的，发了数据之后必须有人来收数据。

func chanDemo() {
	//var c chan int // c == nil
	c := make(chan int)
	go func() {  //这里的匿名函数相当于闭包，引用了外面的c变量
		for {
			n := <-c //开了一个goroutine去接数据
			fmt.Println(n)
		}
	}()
	c <- 1 //往channel中发生数据
	c <- 2
	time.Sleep(time.Millisecond)

}

func main() {
	chanDemo()
}

channel作为参数

func woker(id int, c chan int) {
	for {
		fmt.Printf("Worker %d received %c\n", id, <-c) //因为协程是主动式非抢占，在遇到I/O操作时，会进行调度
	}
}

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

	for i := 0; i < 10; i++ {
		channels[i] <- 'a' + i
	}
	for i := 0; i < 10; i++ {
		channels[i] <- 'A' + i
	}
	time.Sleep(time.Millisecond) //防止main函数先退出

}

func main() {
	chanDemo()
}

channel作为返回值

func createWorker(id int) chan<- int { //返回一个只能往里写数据的channel
	c := make(chan int) //创建一个可以写数据和读数据的channnel
	go func() {
		for {
			fmt.Printf("Worker %d received %c\n", id, <-c)
		}
	}()
	return c
}

func chanDemo() {
	var channels [10]chan<- int //只能往channel中写数据
	for i := 0; i < 10; i++ {
		//channels[i] = make(chan int)
		//go woker(i, channels[i])
		channels[i] = createWorker(i)
	}

	for i := 0; i < 10; i++ {
		channels[i] <- 'a' + i
	}
	for i := 0; i < 10; i++ {
		channels[i] <- 'A' + i
	}
	time.Sleep(time.Millisecond)

}

bufferchannel

func woker(id int, c chan int) {
	for {
		fmt.Printf("Worker %d received %c\n", id, <-c) //因为协程是主动式非抢占，在遇到I/O操作时，会进行调度
	}
}
func bufferedChannel() {
	c := make(chan int, 3) //创建缓冲区为3的channel

	go woker(0, c)
	//只要有人发数据，就必须有人来接数据。缓冲区为3说明 发送的数据小于3时，若没人来接数据，不会出现错误
	c <- 'a'
	c <- 'b'
	c <- 'c'
	c <- 'd'
	time.Sleep(time.Millisecond)
}

channel是可以被发送方进行关闭的，接收方使用两种方法进行判断。

func woker(id int, c chan int) {
	for {
	//当发送方关闭channel之后，接收方还会进行接收，值为channel对应类型的默认值。因此在这里进行判断是否channel关闭
		if n, ok := <-c; ok {
			fmt.Printf("Worker %d received %c\n", id, n) //因为协程是主动式非抢占，在遇到I/O操作时，会进行调度
		} else {
			break
		}
	}
	//第二种方法
	//for n := range c {
	//	fmt.Printf("Worker %d received %c\n", id, n)
	//}
}
func channelClosed() {
	c := make(chan int, 3) //创建缓冲区为3的channel

	go woker(0, c)
	c <- 'a'
	c <- 'b'
	c <- 'c'
	c <- 'd'
	close(c) 
	time.Sleep(time.Millisecond)
}

不要通过共享内存来通信，通过通信来共享内存。
使用channel等待任务结束。两种方法：使用channel进行传递信息；使用sync.WaitGroup类型的变量。

	data := make(chan int)
	exit := make(chan bool)
	go func() {
		for d := range data {
			fmt.Println(d)
		}
		fmt.Println("recv over.")
		exit <- true
	}()

	data <- 1
	data <- 2
	data <- 3
	close(data)
	fmt.Println("send over.")
	<-exit

func doWoker(id int, c chan int, done chan bool) {
	for n := range c {
		fmt.Printf("Worker %d received %c\n", id, n)
		//done <- true //往done中发送了数据，在外面必须有人来接收数据
		go func() {
			done <- true
		}()
	}
}

type worker struct {
	in   chan int
	done chan bool
}

func createWorker(id int) worker {
	w := worker{
		in:   make(chan int),
		done: make(chan bool),
	}
	go doWoker(id, w.in, w.done)
	return w
}

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

	for i, worker := range workers {
		worker.in <- 'a' + i
		//<-workers[i].done //只有收到了数据说明打印已经完成了，才会往下执行
	}
	for i, worker := range workers {
		worker.in <- 'A' + i
		//<-workers[i].done
	}

	//将20个数据全部发出去，然后再进行等待
	for _, worker := range workers {
		<-worker.done
		<-worker.done
	}

}


func doWoker(id int, w worker) {
	for n := range w.in {
		fmt.Printf("Worker %d received %c\n", id, n)
		w.done()
	}
}

type worker struct {
	in   chan int
	done func()
}

func createWorker(id int, wg *sync.WaitGroup) worker {
	w := worker{
		in: make(chan int),
		done: func() {
			wg.Done() //完成一次任务调用一次Done()
		},
	}
	go doWoker(id, w)
	return w
}

func chanDemo() {
	var workers [10]worker
	var wq sync.WaitGroup

	for i := 0; i < 10; i++ {
		workers[i] = createWorker(i, &wq)
	}

	wq.Add(20) //添加20个任务
	for i, worker := range workers {
		worker.in <- 'a' + i

	}
	for i, worker := range workers {
		worker.in <- 'A' + i
	}
	wq.Wait()
}

使用select进行调度。


func generator() chan int {
	out := make(chan int)
	go func() {
		i := 0
		for {
			time.Sleep(
				time.Duration(rand.Intn(1500)) *
					time.Millisecond)
			out <- i
			i++
		}
	}()
	return out
}
func woker(id int, c chan int) {
	for n := range c {
		time.Sleep(time.Second)
		fmt.Printf("Worker %d received %d\n", id, n)
	}
}
func createWorker(id int) chan<- int {
	c := make(chan int)
	go woker(id, c)
	return c
}

func main() {
	//从c1, c2中读出数据 写入worker中
	var c1, c2 = generator(), generator()
	worker := createWorker(0)

	var values []int //生成和消耗的速度不一样，需要存储接收到的数据

	tm := time.After(10 * time.Second) //返回的是一个channel，10s后往这个channel中发生一个时间
	tick := time.Tick(time.Second)
	for {
		var activeWorker chan<- int // activeWorker 是 nil，在select虽然不会运行错误，但是永远不是被select到
		var activeValue int
		if len(values) > 0 {
			activeWorker = worker
			activeValue = values[0]
		}

		select {
		case n := <-c1:
			values = append(values, n)
		case n := <-c2:
			values = append(values, n)
		case activeWorker <- activeValue:
			values = values[1:]
		case <-time.After(800 * time.Millisecond): //如果两次生成数据的时间大于800ms，则会timeout
			fmt.Println("Time out")
		case <-tick: //每1s查看一下数据的长度
			fmt.Println("queue lens = ", len(values))
		case <-tm:
			fmt.Println("Bye")
			return
		}
	}
}

传统的同步机制：WaitGroup，mutex，conditional variable

type atomicInt struct {
	value int
	m     sync.Mutex
}

func (a *atomicInt) increasement() {
	fmt.Println("safe increasement")
	func() {
		a.m.Lock()
		defer a.m.Unlock()
		a.value++
	}()

}

func (a *atomicInt) get() int {
	a.m.Lock()
	defer a.m.Unlock()
	return a.value
}

select语句的用法

通过select可以监听channel上的数据流动。
每一个case语句里必须是一个I/O操作。

elect {

    　　case <-chan1:

        // 如果chan1成功读到数据，则进行该case处理语句

   　　 case chan2 <- 1:

        // 如果成功向chan2写入数据，则进行该case处理语句

    　　default:

        // 如果上面都没有成功，则进入default处理流程

    }

在一个select语句中，Go语言会按顺序从头至尾评估每一个发送和接收的语句。

如果其中的任意一语句可以继续执行(即没有被阻塞)，那么就从那些可以执行的语句中任意选择一条来使用。

如果没有任意一条语句可以执行(即所有的通道都被阻塞)，那么有两种可能的情况：

  • 如果给出了default语句，那么就会执行default语句，同时程序的执行会从select语句后的语句中恢复。

  • 如果没有default语句，那么select语句将被阻塞，直到至少有一个通信可以进行下去。

go的CSP模型

go语言支持两种形式的并发：多线程共享内存；CSP并发模型。

多线程共享内存模型：在访问数据的时候，通过锁来访问。

CSP并发模型：通过channel和goroutine实现。goroutine是Go中并发的执行单位，channel是各个并发单位之前的通信机制，通俗来说就是各个goroutine之间的管道。

传数据用channel <- data，取数据用<-channel，在通信过程中，传数据channel <- data和取数据<-channel必然会成对出现，而且不管传还是取，必阻塞，直到另外的goroutine传或者取为止。

参考一

参考二

陌离
关注
专栏目录
soul_channel.apk（soul安装包）
07-17
soul_channel.apk（soul安装包），供大家下载使用。
channel
磨镜台的博客
07-30 1394
1.向channel写入数据通常会导致程序阻塞，直到有其他的goroutine从这个channel读取数据。 2.如果channel没有数据，从channel读取数据也会导致程序阻塞。 声明channel var chanName chan ElementType 定义channel ch := make(chan int) 定义带缓冲的channel chs := make...
Channel基本介绍
程序员劝退师的博客
06-07 7363
基本介绍 1.NIO的通道类似于流，但有些区别如下 通道可以同时进行读写，而流只能读或者只能写 通道可以实现异步读写数据 通道可以从缓冲读数据，也可以写数据到缓冲: 2.BIO 中的 stream 是单向的，例如 FileInputStream 对象只能进行读取数据的操作，而 NIO 中的通道(Channel)是双向的，可以读操作，也可以写操作。 3.Channel在NIO中是一个接口 public interface Channel extends Closeable{} 4.常用的 Channe
GO的利器之---channel
FindHuni的博客
04-28 557
在GO语言中,channel是一个重要特性,同时也是区别与其它语言的不同之处,一个channel使得并发编程变得简单容易有趣. 在学习channel之前,我觉得我们有必要百度百科一下进程通信,因为channel其实就是一个处理通信过程的一个东西,首先我们要知 道进程通信大致上可以分为低级进程通信和高级进程通信.(具体了解 百度百科讲的已经是很详细了.) 低级通信 由于进程的互...
Go Channel(一)
王佳宇的个人博客
05-09 6558
Channel是Go中的一个核心类型，大部分的人称之为管道，通过它并发核心单元就可以发送或者接收数据进行通讯。 <-这个就是使用Channel的标识,箭头的指向就是数据的流向 package main import "fmt" func main() { ch := make(chan int)//和map和slice数据的类型一样channel需要新创建在使用 go fun...
EBSD分析软件——Channel5下载安装教程.zip
03-03
**EBSD分析软件Channel5详解** EBSD（Electron Backscatter Diffraction）是一种在扫描电子显微镜（SEM）下进行材料微观结构分析的技术，它能够提供晶体取向分布信息，广泛应用于材料科学、地质学等领域。Channel 5...
channel_v3.zip
10-23
《Sublime Text 3的Package Control与Channel_v3.json详解》 在编程世界里，文本编辑器是开发者的重要伙伴，而Sublime Text 3作为一款备受赞誉的代码编辑器，以其强大的功能和高度可定制性赢得了众多程序员的喜爱。...
web_socket_channel:WebSocket的StreamChannel包装器
04-06
web_socket_channel包为WebSocket连接提供包装器。 它提供了一个跨平台的 API，该API的跨平台实现（可在基础上进行通信）， 封装dart:io的WebSocket类的以及封装dart:html的实现。 它还在为WebSocket协议的预定义...
Netty核心之Channel源码学习
01-20
在深入探讨Netty的Channel源码之前，先理解Channel的概念是非常重要的。Channel是Netty中的核心组件，它代表了一个打开的连接，可以用于读写数据。在这个Netty核心之Channel源码的学习过程中，我们将主要关注服务端...
go中管道的理解之---管道作为函数返回值
小豆角的博客
04-26 1802
====描述有误，回头再修改，不要在看了========== go语言channel的作用：同步和通信，也就是通信吧。 【管道可以实现go程之间的通信和同步，一个go去send,另外的go去receive,附带赠送功能----也可以实现桢之间的同步，一个桢receive,一个桢send，简言之：桢返回管道被使用，桢就可以活着了】 因为管道实现的是go之间的桥梁，所以，只要出现chann...
NIO 通道=>Channel
Blake的博客
01-22 272
概述：NIO 通道 Channel 表示IO源跟目标建立的连接线路，channel通过跟buffer的交互，进而完成对数据的相关操作，有一点需要特别明确的是：channel本身并不具备操作数据的能力。  ...
Go中的goroute和channel
weixin_44879611的博客
02-06 786
基础知识 进程和线程 进程 进程是程序在操作系统中的一次执行过程，系统进行资源分配和调度的一个独立单位。 线程 线程是进程的一个执行实体，是CPU调度和分配的基本单位，它是比进程更小的能独立运行的基本单位。 协程 轻量级的线程 -联系 一个进程可以创建和撤销多个线程，同一个进程中的多个线程之间可以并发执行。 并发和并行 并发：多线程程序在一个核的CPU上运行 并行：多线程程序在多个核的CPU...
4.2 ipu_init_channel函数的详细分析
吾皇的博客
08-23 2428
在看这个函数之前，先对ipu内部的channel有所了解，先来看看ipu内部的flow的定义： 对于每个flow，代表数据从摄像头采集到显示（或者保存在内存中）的过程中的一个分步骤，每个flow都对应一个或几个channel，而每个channel的数据流通过程中，是通过DMA传输的，所以每个channel里面又包含一个或几个dma_channel。在这不太好理解，看看手册中的介绍
4.6 ipu_enable_channel函数详细分析
吾皇的博客
08-23 1604
int32_t ipu_enable_channel(struct ipu_soc *ipu, ipu_channel_t channel) { uint32_t reg; uint32_t ipu_conf; uint32_t in_dma; uint32_t out_dma; uint32_t sec_dma; uint32_t thrd_dma; mutex_
5.3_channels
taifyang的博客
06-10 202
5.3 多输入通道和多输出通道 前面两节里我们用到的输入和输出都是二维数组，但真实数据的维度经常更高。例如，彩色图像在高和宽2个维度外还有RGB（红、绿、蓝）3个颜色通道。假设彩色图像的高和宽分别是hhh和www（像素），那么它可以表示为一个3×h×w3\times h\times w3×h×w的多维数组。我们将大小为3的这一维称为通道（channel）维。本节我们将介绍含多个输入通道或多个输出通道的卷积核。 5.3.1 多输入通道 当输入数据含多个通道时，我们需要构造一个输入通道数与输入数据的通道数相同的
21、go语言channel用法
weixin_36020178的博客
05-16 584
21、channelchannel作为参数channel作为数组channel作为返回值 channel作为参数 func worker(id int, c chan int){ for { fmt.Printf("Worker %d received %d\n",id, <- c) } } func chanDemo(){ var c chan int = make(chan int) //c := make(chan int) go worker(0, c) c <- 1
golang 中的 channel 小解
卩杉的博客笔记
01-22 2184
channel 本身是一个数据结构队列 数据是先进先出的 channel 本身是线程安全的 channel 是有类型的，一个 string 的 channel 只能存放 string 类型结构 channel 是引用数据类型，需要 make 后才能使用 给管道中写入数据事，不能超过其容量 channel 关闭时，就不能再往里写数据了，读数据是没有问题的 可以使用 for range 遍历管道，但...
Channel通道使用进阶：通道关闭原则、生产者消费者问题、高并发map
Pistachiout的学习博客
06-13 2192
在进行Channel通道使用之前，先根据总结有缓冲型channel使用的情况，若对下表有疑问可以前往Golang Channel 实现原理与源码分析进行阅读，如下所示：对一个已关闭的通道，进行关闭对一个已关闭的通道，写入数据在多生产者单消费者问题中，我们可以看到我们并没有对业务通道进行关闭，我们只是在给业务通道中写入数据前判断信号通道是否关闭，如果信号通道已经关闭，则直接返回，而不向业务通道中写入数据，因此业务数据并没有关闭，那么就不会引起panic。
rabbitmq channel
最新发布
12-05
RabbitMQ中的channel是一个TCP连接上的虚拟连接，用于在客户端和RabbitMQ之间传递消息。在使用RabbitMQ时，无论是消费还是生产，都需要创建channel和connection。channel是轻量级的，可以在同一个connection上创建多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值