Go 学习之 channel 篇

已于 2022-09-08 09:24:35 修改
阅读量702 收藏
点赞数 1
分类专栏： Go学习笔记 文章标签： golang 学习 sql
于 2022-09-07 18:28:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24433609/article/details/126751446
版权

channel

  1. 函数中启动的 goroutine，【不会随着函数返回而结束，是随着 main 函数结束而结束】
    • 即 goroutine 生命周期 == main 函数声明周期
  2. 可以从【关闭的通道读取值】，但是是【空值】，对于 string 类型 channel 就是 空字符，对于 int 类型 channel 就是 0
    • 因此 n, ok := <-c 这种读取形式，需要通过 ok 判断 channel 是否已关闭
    • 但 for n := range c 这种读取形式，不需要判断 channel 是否已关闭，因为关闭了就不会读取了
package main

import (
	"fmt"
	"time"
)

// 不要通过共享内存来通信，要通过通信来共享内存
// 以前：创建个 flag（共享内存），传递事件的变化
// 现在：创建个 channel（通信），传递事件的变化
func worker2(id int, c chan int) {
	for {
		n, _ := <-c
		// 不加此判断，那么 即使通道关闭，仍会读取（空字符或0）进行继续打印
		// n, ok := <-c
		//if !ok {
		//	break
		//}
		fmt.Printf("Worker %d received %v\n",
			id, n)
	}
}

// worker : 从 channel c 中消费数据
func worker(id int, c chan int) {
	// range 不会从关闭的通道读取【空值】
	for n := range c {
		fmt.Printf("Worker %d received %c\n",
			id, n)
	}
}

// 此处只创建了 一个 channel 就进行了返回
// 但是通过 goroutine 创建的 worker 并【不会因为此函数返回而推出】，goroutine 的生命周期【等同于 main 函数的生命周期】
// 即使 createWorker 返回了，但 main 函数没结束，worker 函数一直运行
// createWorker : 创建 channel 返回，启动 worker 消费此 channel 中的数据
func createWorker(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++ {
		// createWorker : 创建 channel 返回，启动 worker 消费此 channel 中的数据
		channels[i] = createWorker(i)
	}

	// 生产数据 传入 channel
	for i := 0; i < 10; i++ {
		channels[i] <- 'a' + i
	}

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

	time.Sleep(time.Millisecond)
}

// bufferedChannel 创建一个 带缓冲的 channel ，传给 worker 从此 channel 中取数据消费
func bufferedChannel() {
	c := make(chan int, 3)
	go worker(0, c)
	c <- 'a'
	c <- 'b'
	c <- 'c'
	c <- 'd'
	time.Sleep(time.Millisecond)
}

func channelClose() {
	c := make(chan int)
	go worker(0, c)  // range 不会从关闭的通道读取【空值】
	go worker2(1, c) // 测试从关闭通道读取【空值】
	c <- 'a'
	c <- 'b'
	c <- 'c'
	c <- 'd'
	close(c)
	time.Sleep(time.Millisecond)
}

func hello() {
	go func() {
		for {
			fmt.Println("hello")
		}
	}()
	return
}

func main() {
	fmt.Println("Channel as first-class citizen")
	chanDemo()
	fmt.Println("Buffered channel")
	bufferedChannel()
	fmt.Println("Channel close and range")
	channelClose()

	//hello()
	//time.Sleep(1 * time.Millisecond)
}

main 函数的结束时机（保证channel 都运行完成）

  • 通过 wg *sync.WaitGroup 来等待所有的协程结束
    • wg 的值 不必等于 协程的数量，但是必须要等于【所有协程调用 wg.done的次数和】，这样才能保证所有协程的正常运行结束
package main

import (
	"fmt"
	"sync"
)

func doWork(id int,
	w worker) {
	for n := range w.in {
		fmt.Printf("Worker %d received %c\n",
			id, n)
    // 每次 done 就会将计数 -1
		w.done()
	}
}

type worker struct {
	in   chan int
  // 结束逻辑抽象  func 内可实现自定义的结束逻辑
	done func()
}

func createWorker(
	id int, wg *sync.WaitGroup) worker {
	w := worker{
		in: make(chan int),
		// 抽象后 更方便实现自己的结束逻辑
		done: func() {
			wg.Done()
		},
	}
	// 开启 goroutine 消耗数据
	go doWork(id, w)
	return w
}

func chanDemo() {
	var wg sync.WaitGroup
	
	var workers [10]worker
  // 此处开了 10个 协程
	for i := 0; i < 10; i++ {
		workers[i] = createWorker(i, &wg)
	}
	// 通过 waitGroup 等待所有 goroutine 都完成
	wg.Add(20)
  // wg 的值不必和 协程数 相等，但是要 和 done 次数保持相等
  // 可以看到 每个协程 会输入两次数据，因此也就会执行两次 done，10 个协程共 20 次
  // 所以要是 wg 的值为 10，那么 10 此后就退出了，数据就无法全部打印完成
	for i, worker := range workers {
		worker.in <- 'a' + i
	}
	for i, worker := range workers {
		worker.in <- 'A' + i
	}

	wg.Wait()
}

func main() {
	chanDemo()
}

通过通信共享内存

  • 下面的例子是中序遍历
    • Traverse 是传统遍历方法，直接打印出来
    • TraverseWithChannel 也是打印数据，另外将数据传给 channel ，由 main 函数进行读取处理（本例子中是找出最大值）
      • 此处的channel 对于 main 函数来说，相当于一个数据源，可以理解为 python 的 yield 函数
package main

import "fmt"

type Node struct {
	Value       int
	Left, Right *Node
}

func (node *Node) Traverse() {
	node.TraverseFunc(func(n *Node) {
		n.Print()
	})
	fmt.Println()
}
func (node Node) Print() {
	fmt.Print(node.Value, " ")
}

func (node *Node) SetValue(value int) {
	if node == nil {
		fmt.Println("Setting Value to nil " +
			"node. Ignored.")
		return
	}
	node.Value = value
}

func CreateNode(value int) *Node {
	return &Node{Value: value}
}

// 中序遍历  左 根 右
// 对于遍历到的节点，采取的操作进行抽象，用 f 函数
// f 具象化，可以做：记录节点值，或传给 channel 等
func (node *Node) TraverseFunc(f func(*Node)) {
	if node == nil {
		return
	}

	node.Left.TraverseFunc(f)
	f(node)
	node.Right.TraverseFunc(f)
}

func (node *Node) TraverseWithChannel() chan *Node {
	out := make(chan *Node)
  // 开启 goroutine 进行遍历
	go func() {
		node.TraverseFunc(func(node *Node) { // 此 func 就是抽象的实现，将 node 数据放入 channel
      node.Print() // 此处也可实现打印
			out <- node
		})
		close(out)
	}()
	return out
}

func main() {
	var root Node
	// 建树
	root = Node{Value: 3}
	root.Left = &Node{}
	root.Right = &Node{5, nil, nil}
	root.Right.Left = new(Node)
	root.Left.Right = CreateNode(2)
	root.Right.Left.SetValue(4)

	// 中序遍历   正常做法
	root.Traverse()
	// 中序遍历的所有值 采用 channel 记录的方法 都传给 channel c
	// 相当于 python 的 yield
	c := root.TraverseWithChannel()
	// 从 channel c 中取值，找出最大的
	maxNodeValue := 0
	for node := range c {
		if node.Value > maxNodeValue {
			maxNodeValue = node.Value
		}
	}
	fmt.Println("Max node value:", maxNodeValue)
}

// OutPut:
// 0 2 3 4 5 
// 0 2 3 4 5 Max node value: 5

channel select 函数

go : select 的执行顺序

  1. 当多个 case 满足时，select 的选择是随机的
  2. 可以通过 定时器，结合 select 实现定时打印数据，或进行关闭
package main

import (
	"fmt"
	"math/rand"
	"time"
)

// 每隔 1.5s 产生一条数据，输入到 out channel 中
func generator() chan int {
	out := make(chan int)
	// goroutine 不断产生数据
	go func() {
		i := 0
		for {
			time.Sleep(
				time.Duration(rand.Intn(1500)) *
					time.Millisecond)
			out <- i
			i++
		}
	}()
	return out
}

func worker(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 worker(id, c)
	return c
}

func main() {
	// 数据生成器
	var c1, c2 = generator(), generator()
	// 返回一个 channel
	var worker = createWorker(0)
	// 缓存区：用于平衡 数据产生和数据消耗的速度差异，避免数据产生太快，消耗太慢，导致部分数据被覆盖，无法读取到
	var values []int
	// 定时器
	// 10 s 后发送一条 time 的信号
	tm := time.After(10 * time.Second)
	// 每秒 发送一条 time 的消息
	tick := time.Tick(time.Second)
	for {
		// nil cha
		var activeWorker chan<- int
		var activeValue int
		// 缓存区不为空，读取第一个数据
		if len(values) > 0 {
			activeWorker = worker
			activeValue = values[0]
		}
		// 当很多 case 都满足时， select 是随机选择的，没有按照顺序
		select {
		// 将受到的数据，放入到缓存区
		case n := <-c1:
			values = append(values, n)
		case n := <-c2:
			values = append(values, n)
		// 将上面读取的缓存区第一个数据，写入到 channel 中，同时将缓存区 去除 该队首元素
		case activeWorker <- activeValue:
			values = values[1:]
		// 收到此信号，打印 timeout
		case <-time.After(800 * time.Millisecond):
			fmt.Println("timeout")
		// 收到此信号表示，打印缓存区（每秒一次）
		case <-tick:
			fmt.Println(
				"queue len =", len(values))
		// 收到此信号（上面设置为10s) 表示结束
		case <-tm:
			fmt.Println("bye")
			return
		}
	}
}

传统同步机制

通过【共享内存】来通信，因此需要【加锁】，来避免竞争条件下被覆盖

  1. syn.WaitGroup
  2. Mutex
  3. Cond

通过运行 go run -race 文件名.go 可检测出是否有竞争条件导致的脏写或脏读（使数据不正常）

不正常

// 通过运行 go run -race atomic.go 可检测出是否有竞争条件导致的脏写或脏读（使数据不正常）

// atomic.go 文件
package main

import (
	"fmt"
	"sync"
	"time"
)

type atomicInt int

func (a *atomicInt) increment() {
	fmt.Println("safe increment")
	*a++
}

func (a *atomicInt) get() int {
  return int(*a)
}

func main() {
	var a atomicInt
	a.increment()
	go func() {
		a.increment()
	}()
	time.Sleep(time.Millisecond)
	fmt.Println(a.get())
}

正常

// 通过运行 go run -race atomic.go 可检测出是否有竞争条件导致的脏写或脏读（使数据不正常）

// atomic.go 文件
package main

import (
	"fmt"
	"sync"
	"time"
)

type atomicInt struct {
	value int
	lock  sync.Mutex
}

func (a *atomicInt) increment() {
	fmt.Println("safe increment")
	func() {
		a.lock.Lock()
		defer a.lock.Unlock()

		a.value++
	}()
}

func (a *atomicInt) get() int {
	a.lock.Lock()
	defer a.lock.Unlock()

	return a.value
}

func main() {
	var a atomicInt
	a.increment()
	go func() {
		a.increment()
	}()
	time.Sleep(time.Millisecond)
	fmt.Println(a.get())
}
oceanweave
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
golang基础学习资料
12-13
本篇学习资料将深入介绍 Go 语言的基础概念，帮助初学者快速入门。 一、简介 Go 语言的官方文档是学习的首选资源，它包含了详细的教程、语言规范、标准库和工具链的说明。官方文档的易读性和实用性使得自学 Go 语言...
Go语言 channel如何实现归并排序中的merge函数详解
01-03
初识go语言不到半年,我是一次偶然的机会认识了golang这门语言,看到他简洁的语法风格和强大的语言特性,瞬间有了学习他的兴趣 最近学习 Go，但是苦于没有项目练手，于是便逼迫自己：如果想到什么有趣的东西，看能不能...
go channel的学习总结
LYue123的博客
03-10 390
go channel channel是goland中一种特殊的类型的存在，对于goland的学习来说是非常重要的。 channel是goland中goroutine间的通信的一种方式，可以类比成 Unix 中的进程的通信方式管道。 并发模型 因为goland是一个支持并发的编程语言，而且channel又在并发中起了关键作用，所以我们简单介绍一下并发模型，传统的并发模型主要是Actor和GSP两种，...
go语言核心—channel学习
wudawei071193的博客
09-02 166
这周来学习一下go语言的核心之一-channel，都知道go语言支持高并发，其原因就是goroutine-协程的存在，这是一种逻辑上等同于线程，而实际和线程又和线程有所不同，关于协程的学习，等下次结合这线程一起学习对比一下。今天主要简单的学习一下线程之间通讯的方式-channel。 一、channle的基本概念 channels是go中不同goroutines交互数据的一种通道，也就是说如果两...
Go学习笔记—Channel通道
koooooooo5的博客
12-01 542
Go并发通信——Channel ​ Go语言的并发模型是CSP（Communicating Sequential Processes），提倡通过通信共享内存而不是通过共享内存而实现通信。（DO NOT COMMUNICATE BY SHARING MEMORY; INSTEAD, SHARE MEMORY BY COMMUNICATING.） ​ 如果说goroutine是Go程序并发的执行体，channel就是它们之间的连接。channel是可以让一个goroutine发送特定值到另一个gorouti
GO语言学习——(1) channel入门
学习学习再学习
05-20 273
（一）简介 Go语言所提倡的一句话是：应该以通信作为手段来共享内存，这句话最直接的体现就是channel，它也是Go语言预定义的数据类型之一。 channel提供了一种机制，它既可以同步两个并发执行的函数，又可以额昂两个函数通过相互传递特定类型的值来通信。 （二）channel的基本概念 在go语言中，chnnel既指通道类型，也指代可以传递某种类型的值的通道。通道即某一...
golang channel总结（很强-很全）
最新发布
HappyLearnerL的博客
11-24 942
golang channel
GO语言基础学习文档
01-08
本篇学习文档主要涵盖了GO语言的基础知识，包括环境搭建、命令使用、基本语法、流程控制、函数、面向对象特性以及并发和Web开发的基础。 一、GO语言环境搭建 在开始学习GO语言之前，首先需要配置好环境。GOROOT是GO...
go代码-学习GO语言对应的结构
07-14
本篇文章将详细探讨`main.go`文件中的Go语言结构，并结合`README.txt`文件中的指导，深入解析Go代码的基本构造。 Go语言的程序执行始于`main`包，因此`main.go`文件通常是程序的入口点。在`main.go`中，我们通常会...
golang语言中的channel语法
m0_51530927的博客
04-30 2136
golang语言中的channel语法有缓冲无缓冲，单向双向，newtimer，time。aftertimer.Stop，select上述语法的容量应该大于0，以便通道具有缓冲区。默认情况下，无缓冲通道的容量为0，因此在之前创建通道时省略了容量参数。如果不关闭的话，就会出现死锁。因为子 go 中都已放入暖冲后没有可用的供给 main go就会导致main go一直等待。单流程下一个 go 只能监控一个 channel 的状态，select 可以完成监控多个 channel 的状态。...
GO语言-管道channel
qq522044637的博客
06-25 398
GO语言-channel通道
Go中的channel
热门推荐
始梦的少年的博客
04-25 1万+
channel （1）channel本身是一个队列，先进先出 （2）线程安全，不需要加锁 （3）本身是有类型的，string, int 等，如果要存多种类型，则定义成 interface类型 （4）channel是引用类型，必须make之后才能使用，一旦 make，它的容量就确定了，不会动态增加！！它和map，slice不一样 特点： （1）一旦初始化容量，就不会改变了。 （2）当写满时，不可以写，取空时，不可以取。 1、关于 channel的声明和使用的代码： package main import (
Go channel的关闭和广播
weixin_42094659的博客
12-22 201
channel的关闭 1、想关闭的channel发送数据，会导致panic 2、v,ok <- ch; ok为bool值，true标识正常接受，false标识通道关闭 3、所有的channel接收者都会在channel关闭时，立刻从堵塞等待中返回且上述ok值为false。这个广播机制常被利用，进行向多个订阅者同时发送信号。如退出信号 //生产者停止生产数据，消费者怎么知道？ func dat...
golang的channel浅析
Gdl.痕迹 的博客
08-04 318
简介 channel是golang的一个重要特性，可用于goroutine同步和通信，channel基于共享内存实现，具有FIFO特性。 chan的分类 //read and write chan //write only chan<- //read only <-chan 此外还可以分为有缓冲和无缓冲chan。 无缓冲chan 无缓冲chan，没有缓冲队列，其读写两端需要同步，否之阻塞。可用于goroutine之间的同步操作。 创建无缓冲chan： ch := make(chan int)
机器学习对非数值对象的处理
qq_20880939的博客
08-03 2675
计算机对于数据处理形式只能是数据，因此现在假设数据是非数值的形式，具体形式可能是不同的类别，这时我们需要将类别转化为独热编码的形式才能对数据进行进一步处理。 具体转化工具是利用机器学习的Scikit-learn的工具包，具体展示在下面: 假设我们有一些列数据，暂且命名为housing,上面结果可以看出，在housing的所有属性上，ocean_proximity类型为object,并不是f...
php充值奖励部分,BLUE引擎充值角本多充多送脚本累计充值奖励教程
weixin_32389427的博客
03-11 1126
()%100[@main]\ \本文来自织梦━━━━━━━━━━━━━━━━━━━━━━━━━━━\ \ \dedecms.com \ \ \━━━━━━━━━━━━━━━━━━━━━━━━━━━\内容来自dedecms[@2]#IFCHECK [7] 0CHECKGAMEGIRD > 499#actcopyright dedecmsSET [7] 1Gmexecute 11 封印之魂...
Go Channel 详解
淡淡忧桑
10-27 7871
Go Channel 详解
Go channel的使用场景,用法总结
Mark66890620
04-06 2128
在介绍10种操作前，先简要介绍下channel的使用场景、基本操作和注意事项。 channel的使用场景 把channel用在数据流动的地方： 消息传递、消息过滤 信号广播 事件订阅与广播 请求、响应转发 任务分发 结果汇总 并发控制 同步与异步 ... channel的基本操作和注意事项 channel存在3种状态： nil，未初始化的状态，只进行了声明，或者手动赋值为nil active，正常的channel，可读或者可写 closed，已关闭，千万不要误认为关闭chann
Go channel 通道
魔筝炼药师
05-28 368
go routine 可以使用 channel 来进行通信，使用通信的手段来共享内存。使用形式有下面几种， 无缓冲 channel 有缓冲 channel 需要注意 channel 的关闭时机 单向 channel channel + select，实现多路复用 基本语法 make(chan Type) 等价于 make(chan Type,0) make(chan Type, capacity) ch<- value // 发送 value 到 ch <- ch...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值