Go语言系列(十一):channel

最新推荐文章于 2021-01-11 09:03:00 发布
最新推荐文章于 2021-01-11 09:03:00 发布
阅读量387 收藏
点赞数 1
分类专栏： Go语言基础 文章标签： go golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42012911/article/details/106531217
版权

channel

  • 不要通过共享内存来通信，要通过通信来共享内存
  • channel是用来协程通信的
    在这里插入图片描述
  • 错误做法
package main

import "fmt"

func chanDemo() {
	//	var c chan int // chan  通道里面是int类型  c == nil
	c := make(chan int) // 这里定义没有缓存，所以接收到一个他就会阻塞的到这个值被取走

	c <- 1 // 把 1 送到c中
	c <- 2
	c <- 3
	n:= <-c
	//fatal error: all goroutines are asleep - deadlock!
	//这样因为没人其他的协程接这个通道的数据 所以报错 死锁
	fmt.Println(n)
}

func main() {
	chanDemo()
}
  • 开一个协程接收数据

func chanDemo() {
	c := make(chan int)
	go func() {
		for {
			n := <-c
			fmt.Println(n)
			//1
			//2
			//3

		}
	}()
	c <- 1 // 把 1 送到c中
	c <- 2
	c <- 3
	time.Sleep(time.Millisecond)
}

func main() {
	chanDemo()
}



// chan 作为参数
func worker(c chan int) {
	for {
		//n := <-c
		//fmt.Println(n)
		fmt.Printf("%c",<-c)

	}
}
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] <- 'a'+i
	}
	time.Sleep(time.Millisecond)
}

//func createWorker(id int) <-chan int { //这样写表示只用来发送数据 
func createWorker(id int) chan<- int { //这样写表示只用来接收数据 用于发送数据会报错
	c := make(chan int)
	go func() {
		for {
			fmt.Printf("worker %d receiver:%c\n", id, <-c)

		}
	}()
	return c
}
func chanDemo() {
	var channels [10]chan<- int // 数组
	for i := 0; i < 10; i++ {
		channels[i] = createWorker(i)
	}

	for i := 0; i < 10; i++ {
		channels[i] <- 'a' + i
	}
	time.Sleep(time.Millisecond)
}
/、
func bufferedChannel() {
	c := make(chan int, 3) //定义缓冲区
	//因为有大小为3的缓冲区 所以就算没有协程来接，传入数据不大于3个是不会报错的
	c <- 1
	c <- 2
	c <- 3
}

func main() {
	bufferedChannel()
	//chanDemo()
}

//
close(c) // 通道也可以关闭 通道关闭之后，另一边还是可以接收到数据，是这个类型的默认0值
	// 可以用两个数来接收 n, ok := <-c ok表示是否有值 然后用if ok 做判断
	// 也可以用for n:= range c 用range接收数据 等到c发完就跳出来
	// 如果c不close 会永远接收下去，等到main退出，他也就退出，chan可以不关闭

  • channel

  • buffered channel

  • range

  • 发送数据c<-1

  • 接收数据n:=<-c

  • chan<-int只能发数据给channel<-chan int只能从channel接收数据

  • close(c)：关闭channel，发送方一旦关闭channel，接收方一直能接收到数据，但是收到的是channel中具体类型的零值

  • 只有发送方才能close channel，range会自动检查channel是否close

  • 如果发送方没有使用close方法，接收方进入循环后会阻塞，也就是说，一个chan如果有close方法，那就是非阻塞的，没有则是阻塞的

使用Channel等待任务结束

方法一
// done用于接收，这样来替换 	time.Sleep(time.Millisecond)
type workers struct {
	in   chan int
	done chan bool
}

func createWorker(id int, w workers) {
	go func() {
		for {
			fmt.Printf("worker %d receiver:%c\n", id, <-w.in)
			w.done <- true //打印完就送一个true给done

		}
	}()
}

func chanDemo() {
	var work [10]workers // 数组
	for i := 0; i < 10; i++ {
		work[i] = workers{
			in:   make(chan int),
			done: make(chan bool),
		}
		createWorker(i, work[i])
	}
	for i := 0; i < 10; i++ {
		work[i].in <- 'a' + i
		<- work[i].done // 如果done没有数据 这里会阻塞
	}

}

func main() {
	chanDemo()
}

缺点：顺序打印，不如不用

worker 0 receiver:a
worker 1 receiver:b
worker 2 receiver:c
worker 3 receiver:d
worker 4 receiver:e
worker 5 receiver:f
worker 6 receiver:g
worker 7 receiver:h
worker 8 receiver:i
worker 9 receiver:j
  • 解决方式
func chanDemo() {
	var work [10]workers // 数组
	for i := 0; i < 10; i++ {
		work[i] = workers{
			in:   make(chan int),
			done: make(chan bool),
		}
		createWorker(i, work[i])
	}
	for i := 0; i < 10; i++ {
		work[i].in <- 'a' + i
	}
	for _, worker := range work {
		<-worker.done
	}

}
通过waitGroup等待
type workers struct {
	in   chan int
	wg *sync.WaitGroup //指针才能使用同一个wg
}

func createWorker(id int, wg *sync.WaitGroup) workers{
	w := workers{
		in : make(chan int),
		wg : wg,
	}
	go func() {
		for {
			fmt.Printf("worker %d receiver:%c\n", id, <-w.in)
			wg.Done()
		}
	}()
	return w
}

func chanDemo() {
	var wg sync.WaitGroup
	wg.Add(20) //20个任务
	var work [10]workers // 数组
	for i := 0; i < 10; i++ {
		work[i] = createWorker(i, &wg) //所有的要用同一个wg 所以传指针
	}
	for i := 0; i < 10; i++ {
		work[i].in <- 'a' + i
	}
	for i := 0; i < 10; i++ {
		work[i].in <- 'A' + i
	}
	wg.Wait() //等待20个任务完成再往下执行
}

func main() {
	chanDemo()
}

使用Select来进行调度

func main() {

	var c1, c2 chan int // nil 
	select { //哪一个条件满足就走哪个条件
	case n := <-c1:
		fmt.Println("received from c1:", n)
	case n := <-c2:
		fmt.Println("received from c2:", n)
	default:
		fmt.Println("no value") //这里 
	}
}
/
func generator() chan int {
	c := make(chan int)
	i := 0
	go func() {
		for {
			time.Sleep(time.Millisecond * time.Duration(rand.Intn(1500)))
			c <- i
			i++
		}
	}()
	return c
}

func main() {
	var c1, c2  = generator(), generator()
	for  {
	select { //哪一个条件满足就走哪个条件
	case n := <-c1:
		fmt.Println("received from c1:", n)
	case n := <-c2:
		fmt.Println("received from c2:", n)
	}

	}
}
//
func main() {
	var c1, c2 = generator(), generator()
	w := createWorker(0)
	var n int
	for {
		select { //哪一个条件满足就走哪个条件
		case n = <-c1:
			fmt.Println("received from c1:", n)
		case n = <-c2:
			fmt.Println("received from c2:", n)
		case w <- n: //也可以发 但是因为w不是nil 如果n没有值他会输出零值 这里就会无限循环走这个逻辑
		}
	}
}
///解决办法利用chan的nil值

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

func main() {
	var c1, c2 = generator(), generator()
	w := createWorker(0)
	var n int
	hasValue := false
	for {
		var activeWork chan int
		if hasValue {
			activeWork = w
		}
		select { //哪一个条件满足就走哪个条件
		case n = <-c1:
			hasValue = true
			fmt.Println("received from c1:", n)
		case n = <-c2:
			hasValue = true
			fmt.Println("received from c2:", n)
		case activeWork <- n: //这样的话如果hasValue为false 这里activeWork为nil这样就会被阻塞住
			hasValue = false // 但是这样数据会丢失因为接收和发送的速度不匹配，可以弄一个队列然后存到队列中去 然后hasValue的判断规则为队列长度是否大于0
		}
	}
}
//

func main() {
	var c1, c2 = generator(), generator()
	w := createWorker(0)
	var n int
	var values []int
	for {
		var activeWork chan int
		if len(values) > 0 {
			activeWork = w
		}
		select { //哪一个条件满足就走哪个条件
		case n = <-c1:
			values = append(values, n)
			fmt.Println("received from c1:", n)
		case n = <-c2:
			values = append(values, n)
			fmt.Println("received from c2:", n)
		case activeWork <- n: 
			values = values[1:] //弄一个队列然后存到队列中去 然后hasValue的判断规则为队列长度是否大于0
		}
	}
}
计时器的使用
func main() {
	var c1, c2 = generator(), generator()
	w := createWorker(0)
	var n int
	var values []int
	tm := time.After(10 * time.Second) //10s过后，会往tm通道发送数据
	for {
		var activeWork chan int
		if len(values) > 0 {
			activeWork = w
		}
		select { //哪一个条件满足就走哪个条件
		case n = <-c1:
			values = append(values, n)
			fmt.Println("received from c1:", n)
		case n = <-c2:
			values = append(values, n)
			fmt.Println("received from c2:", n)
		case activeWork <- n:
			values = values[1:] //弄一个队列然后存到队列中去 然后hasValue的判断规则为队列长度是否大于0
		case <-tm:
			fmt.Println("bye") //10s过后bye
			return
		}
	}
}
  • Select的使用
  • 定时器的使用
  • 在Select中使用nil channel

传统的同步机制(尽量少用)

  • waitGroup
  • mutex
  • Cond
type atomicInt struct {
	value int
	lock sync.Mutex
}
func (a *atomicInt) get() int{
	a.lock.Lock()
	defer a.lock.Unlock()
	return a.value
}
func (a *atomicInt) increment() {
	a.lock.Lock()
	defer a.lock.Unlock() //defer的正确用法
	a.value++
}
func main() {
	var a atomicInt
	a.increment()
	go func() {
		a.increment()
	}()
	time.Sleep(time.Millisecond)
	fmt.Println(a.get())
}

// 如果要在一段代码端同步，那就变成一个匿名函数就好了
func (a *atomicInt) increment() {
	func() {
		a.lock.Lock()
		defer a.lock.Unlock() //defer的正确用法
		//............
		a.value++
		//.........
	}()
}
肖肖肖肖小小
关注
专栏目录
Kotlin协程通信机制: Channel
微赚淘客开发者博客
12-03 5万+
Coroutines Channels Java中的多线程通信, 总会涉及到共享状态(shared mutable state)的读写, 有同步, 死锁等问题要处理. 协程中的Channel用于协程间的通信, 它的宗旨是: Do not communicate by sharing memory; instead, share memory by communicating. Channe...
Go语言Channel深度理解
Simple子夜
07-12 268
Go语言采用的是并发模型是（CSP），提倡"通过通信共享内存"，而不是"通过共享内存实现通信"，**如果说goroutine是Go程序并发的执行体，那么channel则是它们之前的连接。channel是可以让一个goroutine发送一个特定的值到另外一个goroutine的通信机制**
一文带你解密 Go 语言之通道 channel
EDDYCJY的博客
01-11 2200
大家好，我是煎鱼。今天这篇文章主要是针对 Go channel 的重点分析，一开始写的时候以为范围不会太大，但洋洋洒洒还是写破了万字，成为了一篇覆盖面较广和有一定深度的长文分析。大家觉得...
go语言中的goroutine和channel
code_feien的博客
05-11 6419
go语言中的goroutine和channelgoroutine的特性chan有关 goroutine的特性 go的执行是非阻塞的，不会等待 go后面的函数的返回值会被忽略 调度器不能保证多个goroutine的执行次序 没有父子goroutine的概念，所有的goroutine是平等地被调度和执行的 Go程序在执行时会单独为main函数创建一个goroutine，遇到其他go关键字时再去创建其他的goroutine Go没有暴露goroutine id给用户，所以不能再一个goroutine里面显示地操
Channel类详解[1-3]
阳光梦的专栏
05-13 6万+
Channel.h // Copyright 2010, Shuo Chen.  All rights reserved. // http://code.google.com/p/muduo/ // // Use of this source code is governed by a BSD-style license // that can be found in the Licen
9、Go语言channel的操作
热门推荐
行走的皮卡丘
11-22 7万+
Go语言channel的操作。
Go语言实战：驾考系统
06-11
Go语言的并发特性可以用来实时监控考试过程，一旦检测到违纪行为，可以通过channel立即通知相关人员。同时，为了防止过多的通知阻塞系统，可以使用buffered channels或者定时器来控制通报频率。 4. 成绩录入与查询...
Go语言深度探索：Channel、Map与Interface解析
"Go 语言问题集包含了一系列关于Go语言的常见问题，涵盖了channel、map、interface、标准库、unsafe、goroutine调度器以及编译和链接等多个方面。这本书籍旨在帮助读者深入理解Go语言的特性和内部机制。" **Channel...
Go语言教程 ：go语言免费教程网站分享
02-28
“编程网”(https://c.biancheng.net/golang/) 提供了一系列高质量的Go语言教程，包括基础入门、进阶技巧以及实战案例等内容。这些教程非常适合初学者快速掌握Go语言的核心概念和技术要点。 1. **基础入门** - **...
Go语言数据交换：结构体的序列化与反序列化艺术
最新发布
07-23
Go语言的标准库提供了一系列工具来支持不同格式的数据序列化和反序列化。 - **`encoding/json`**：此包提供了将Go语言中的结构体序列化为JSON格式以及将JSON字符串反序列化回结构体的功能。JSON格式因其轻量级且易...
深度解密Go语言之channel
weixin_44014995的博客
10-23 2648
什么是CSP CSP经常被认为是Go在并发编程上成功的关键因素.CSP全称是“Communicating Sequential Processes”（通讯顺序进程）、 CSP 也是一门自定义的编程语言，作者定义了输入输出语句，用于 processes 间的通信（communicatiton）。processes 被认为是需要输入驱动，并且产生输出，供其他 processes 消费，processes 可以是进程、线程、甚至是代码块。 Go 是第一个将 CSP 的这些思想引入，并且发扬光大的语言。 ..
Channel 用法
weixin_45063710的博客
07-08 5万+
channeljava的NIOchannel实现举个栗子 java的NIO 我们知道java的流是单向的，可读可写类似于channel里的通道， 1、区别在于流是半双工，通道是全双工 2、通道读写要buffer channel实现 FileChannel 从文件中读写数据 DatagramChannel UDP读写网络中数据 SocketChannel TCP读写网络… ServerSocketChannel ：像WEB服务器对每个进入连接创建SocketChannel 举个栗子 RandomAccess
Go系列 --channel 及其介绍
一叶知秋
11-12 2181
序言 go 中以 goroutine 为最小并发单元，具有比线程更小的开销，使得go的并发和切换性能较强。 而goroutine 之间的相互通信就需要靠 channel来实现。不像 一般语言，线程之间共享信息的方式是通过共享内存方式来进行， 为了保护数据安全，通常访问时候需要加锁，或者采用乐观锁技术（CAS比较)，当然go也实现了共享内存加锁方式。 而channel 就像是信道，两个不同的goroutine 相互通信时候，一方充当消费者，另一方充当生产者，信道就像是消息队列 有FIFO的性质，g...
channel代码示例
清涵
05-01 2万+
channel代码示例package cn.com.github.immortals;import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.RandomAccessFile; import java
NIO详解（九）：Channel详解
Master-TJ的个人博客
05-20 2146
1. Channel概述 Java NIO的通道类似流，但又有些不同。 Channel既可以从通道中读取数据，又可以写数据到通道。但流的读写通常是单向的。 Channel通道可以异步地读写。 Channel通道中的数据总是要先读到一个Buffer，或者总是要从一个Buffer中写入。 通道中的数据总是要先读到一个Buffer，或者总是要从一个Buffer中写入。 1.1 Channel ...
总结了才知道，原来channel有这么多用法！
QQ1528884535的专栏
10-14 4万+
这篇文章总结了channel的10种常用操作，以一个更高的视角看待channel，会给大家带来对channel更全面的认识。在介绍10种操作前，先简要介绍下channel的使用场景、基本...
channel
txj236的专栏
06-15 2万+
channel 是有类型的管道，可以用 channel 操作符  对其发送或者接收值。 ch <- v // 将 v 送入 channel ch。 v := （“箭头”就是数据流的方向。） 和 map 与 slice 一样，channel 使用前必须创建： ch := make(chan int) 默认情况下，在另一端准备好之前，发送和接收都会阻塞。这使得 gorou
Go语言系列(十四) ：struct{}和struct{}{}
Xiao_xiaoxiao
06-09 3461
struct{} 和 struct{}{} 一般我们知道struct在Go语言中是用于定义结构类型 type User struct { Name string Age int } 而struct {}是一个无元素的结构体类型，通常在没有信息存储时使用。优点是大小为0，不需要内存来存储struct {}类型的值。 struct {} {}是一个复合字面量，它构造了一个struct {}类型的值，该值也是空。 比如我们可以用map[string]struct{}来当作成一个set来用
Go系列（四）：Go的依赖管理
Xiao_xiaoxiao
06-01 721
依赖 依赖就是别人写的库 依赖管理的三个阶段 - GOPATH - GOVENDOR - go mod GOPATH 就是给一个目录，然后我的所有的依赖就来这个目录下面找 默认在～/go 默认会去GOPATH的src目录下找 问题：所有项目都在GOPATH目录下，这样会导致目录越来越大，几乎所有的github都镜像到GOPATH下 GOVENDOR 每一个项目都有一个vendor目录，用来存放第三方的库，这样的话，默认先去vendor目录下面找，然后如果找不到再去go的安装目录找，再找不到去GOP
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值