Go chan基础1

已于 2023-02-27 22:17:44 修改
阅读量197 收藏
点赞数
分类专栏： Go 文章标签： golang
于 2023-02-27 12:09:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42430947/article/details/129239179
版权

值表示
通道类型是一个引用类型，所以初始化前，为此类型的零值：nil。
初始化通道
缓冲通道（10）：
make（chan int，10）
make（chan int）
非缓冲通道：
make（chan int）
一个通道值的缓冲容量总是固定不变的。如果第二个参数值被省略了,就表示被初始化的这个通道永远无法缓冲任何元素值。发送给它的元素值应该被立刻取走，否则发送方的goroutine就会被暂停(或者说阻塞),直到有接收方接收这个元素值。
需要特别注意：
试图从一个未被初始化的通道值（即值为nil的通道）那里接收值，会造成当前goroutine的永久阻塞！
同样，向nil 通道 发送值，goroutine也会被永久阻塞！
操作特性
通道是在多个goroutine之间传递数据和同步数据的重要手段，而对通道的操作本身也是同步的。
在同一时刻，仅有一个goroutine能向一个通道发送值，
同时也仅有一个goroutine能接收值。
在通道中，先进先出，相当于FIFO的消息队列。
通道中的每个值都只可能被某一个goroutine接收，已接受的值会立刻从通道中删除。

Go语言中 空结构类型的变量是不占用任何内存空间的，
并且所有该类型的变量都拥有相同的内存地址。
建议用于传递"信号"的通道，都以struct{}作为元素类型，除非需要传递更多信息。

package main

import (
	"fmt"
	"time"
)

var strChan = make(chan string, 3)

func main() {

	// 通知接受操作chan
	syncChan1 := make(chan struct{}, 1)
	// 避免主goroutine过早结束
	syncChan2 := make(chan struct{}, 2)
	go func() { // 用于接收操作。
		<-syncChan1
		fmt.Println("Received a sync signal and wait a second... [receiver]")
		time.Sleep(time.Second)
		for {
			if elem, ok := <-strChan; ok {
				fmt.Println("Received:", elem, "[receiver]")
			} else {
				break
			}
		}
		fmt.Println("Stopped. [receiver]")
		syncChan2 <- struct{}{}
	}()
	go func() { // 用于发送操作。
		for _, elem := range []string{"a", "b", "c", "d"} {
			strChan <- elem
			fmt.Println("Sent:", elem, "[sender]")
			if elem == "c" {
				syncChan1 <- struct{}{}
				fmt.Println("Sent a sync signal. [sender]")
			}
		}
		fmt.Println("Wait 2 seconds... [sender]")
		time.Sleep(time.Second * 2)
		close(strChan)
		syncChan2 <- struct{}{}
	}()
	<-syncChan2
	<-syncChan2
}


//输出
Sent: a [sender]
Sent: b [sender]
Sent: c [sender]
Sent a sync signal. [sender]
Received a sync signal and wait a second... [receiver]
Received: a [receiver]
Received: b [receiver]
Received: c [receiver]
Received: d [receiver]
Sent: d [sender]
Wait 2 seconds... [sender]
Stopped. [receiver]

在这里插入图片描述

除此之外,如果有多个goroutine因向同一个已满的通道发送元素值而被阻塞,那么当该通道中有多余空间的时候,最早被阻塞的那个goroutine会最先被唤醒。对于接收操作来说，也是如此，一旦已空的通道中有了新的元素值，那么最早因从该通道接收元素值而被阻塞的那个goroutine会最先被唤醒。
并且, Go运行时系统每次只会唤醒一个goroutine。

还有一点需要注意：发送方向通道发送的值会被复制，接收方接收的总是该值的副本,而不是该值本身。经由通道传递的值至少会被复制一次,至多会被复制两次。
例如,当向一个已空的通道发送值，且已有至少一个接收方因此等待时，该通道会绕过本身的缓冲队列，直接把这个值复制给最早等待的那个接收方。
又例如，当从一个已满的通道接收值,且已有至少一个发送方因此等待时,该通道会把缓冲队列中最早进入的那个值复制给接收方,再把最早等待的发送方要发送的数据复制到那个值的原先位置上。通道的缓冲队列属于环形队列,所以这样做是没问题的。
这种情况下,涉及的那两个值在传递到接收方之前都会被复制两次。
因此，当接收方从通道接收到一个值类型的值时，对该值的修改就不会影响到发送方持有的那个源值。但对于引用类型的值来说,这种修改会同时影响收发双方持有的值。

// chanval1.go
package main

import (
	"fmt"
	"time"
)

var mapChan = make(chan map[string]int, 1)

func main() {
	syncChan := make(chan struct{}, 2)
	go func() { // 用于演示接收操作。
		for {
			if elem, ok := <-mapChan; ok {
				elem["count"]++
			} else {
				break
			}
		}
		fmt.Println("Stopped. [receiver]")
		syncChan <- struct{}{}
	}()
	go func() { // 用于演示发送操作。
		countMap := make(map[string]int)
		for i := 0; i < 5; i++ {
			mapChan <- countMap
			time.Sleep(time.Millisecond)
			fmt.Printf("The count map: %v. [sender]\n", countMap)
		}
		close(mapChan)
		syncChan <- struct{}{}
	}()
	<-syncChan
	<-syncChan
}


//输出
The count map: map[count:1]. [sender]
The count map: map[count:2]. [sender]
The count map: map[count:3]. [sender]
The count map: map[count:4]. [sender]
The count map: map[count:5]. [sender]
Stopped. [receiver]

在这里插入图片描述

chan val 值类型

// chanval2.go
package main

import (
	"fmt"
	"time"
)

// Counter 代表计数器的类型。
type Counter struct {
	count int
}

// 引用类型，其值类型属性不会被修改
var mapChan = make(chan map[string]Counter, 1)
//var mapChan = make(chan map[string]*Counter, 1)

func main() {
	syncChan := make(chan struct{}, 2)
	go func() { // 用于演示接收操作。
		for {
			if elem, ok := <-mapChan; ok {
				counter := elem["count"]
				counter.count++
			} else {
				break
			}
		}
		fmt.Println("Stopped. [receiver]")
		syncChan <- struct{}{}
	}()
	go func() { // 用于演示发送操作。
		countMap := map[string]Counter{
			"count": Counter{},
		}
		//countMap := map[string]*Counter{
		//	"count": &Counter{},
		//}
		for i := 0; i < 5; i++ {
			mapChan <- countMap
			time.Sleep(time.Millisecond)
			fmt.Printf("The count map: %v. [sender]\n", countMap)
		}
		close(mapChan)
		syncChan <- struct{}{}
	}()
	<-syncChan
	<-syncChan
}


//输出
The count map: map[count:{0}]. [sender]
The count map: map[count:{0}]. [sender]
The count map: map[count:{0}]. [sender]
The count map: map[count:{0}]. [sender]
The count map: map[count:{0}]. [sender]
Stopped. [receiver]

chan val 引用类型

package main

import (
	"fmt"
	"time"
)

// Counter 代表计数器的类型。
type Counter struct {
	count int
}

//var mapChan = make(chan map[string]Counter, 1)
// 指针引用类型的指针类型，其值类型属性 会被修改
var mapChan = make(chan map[string]*Counter, 1)

func main() {
	syncChan := make(chan struct{}, 2)
	go func() { // 用于演示接收操作。
		for {
			if elem, ok := <-mapChan; ok {
				counter := elem["count"]
				counter.count++
			} else {
				break
			}
		}
		fmt.Println("Stopped. [receiver]")
		syncChan <- struct{}{}
	}()
	go func() { // 用于演示发送操作。
		//countMap := map[string]Counter{
		//	"count": Counter{},
		//}
		countMap := map[string]*Counter{
			"count": &Counter{},
		}
		for i := 0; i < 5; i++ {
			mapChan <- countMap
			time.Sleep(time.Millisecond)
			fmt.Printf("The count map: %v. [sender]\n", countMap)
		}
		close(mapChan)
		syncChan <- struct{}{}
	}()
	<-syncChan
	<-syncChan
}


The count map: map[count:0xc00001a078]. [sender]
The count map: map[count:0xc00001a078]. [sender]
The count map: map[count:0xc00001a078]. [sender]
The count map: map[count:0xc00001a078]. [sender]
The count map: map[count:0xc00001a078]. [sender]
Stopped. [receiver]

关闭通道

package main

import "fmt"

func main() {
	dataChan := make(chan int, 5)
	syncChan1 := make(chan struct{}, 1)
	syncChan2 := make(chan struct{}, 2)
	go func() { // 用于演示接收操作。
		<-syncChan1
		for {
			if elem, ok := <-dataChan; ok {
				fmt.Printf("Received: %d [receiver]\n", elem)
			} else {
				break
			}
		}
		fmt.Println("Done. [receiver]")
		syncChan2 <- struct{}{}
	}()
	go func() { // 用于演示发送操作。
		for i := 0; i < 5; i++ {
			dataChan <- i
			fmt.Printf("Sent: %d [sender]\n", i)
		}
		close(dataChan)
		syncChan1 <- struct{}{}
		fmt.Println("Done. [sender]")
		syncChan2 <- struct{}{}
	}()
	<-syncChan2
	<-syncChan2
}

在这里插入图片描述

星星点点洲
关注
专栏目录
Go语言面试系列：Go基础类型大全
Viper的程序员修炼手册
09-29 1010
Go语言面试系列：Go基础类型大全 go语言自带的基础类型包括 int ：有符号的整数类型，具体占几个字节要看操作系统的分配，不过至少分配给32位。 uint：非负整数类型，具体占几个字节要看操作系统的分配，不过至少分配给32位。 int8：有符号的整数类型，占8位bit，1个字节。范围从负的2的8次方到正的2的8次方减1。 int16：有符号的整数类型，占16位bit，2个字节。范围从负的2的16次方到正的2的16次方减1。 int32：有符号的整数类型，占32位bit，4个字节。范围从负的2的32次方
Go基础入门
编程小白养成手记
01-04 2028
Go语言介绍 解释型语言和编译型语言的区别。 Go语言是编译型语言。 Go语言的特点（自带垃圾回收，天生支持并发） 语法简洁 开发效率高 执行性能好 Go的依赖管理 为什么需要依赖管理 最早的时候，Go所依赖的所有第三方库都在GOPATH目录下，这就导致同一个库只能保存在一个版本的代码，如果不同的项目依赖同一个库的不同版本，就没办法了。 godep 从1.5开始引入vendor模式，如果项目目录下有vendor目录，那么go工具链就会优先使用vender内的包进行编译，测试等。 godep是一个通过v
gochan：用Go编写的半独立式图像板服务器
02-05
高尚 用Go编写的半独立图像板服务器 Gochan的工作方式类似于Kusaba X，Tinyboard等。 这样，Gochan会生成静态HTML文件，可以选择由单独的Web服务器提供该文件。 演示安装： ： 安装 基本安装（从发行版开始） 将.tar.gz或.zip文件解压缩到目录（例如，您的主目录）中 将gochan.example.json复制到gochan.json或（如果您使用的是类似UNIX的操作系统）/etc/gochan/gochan.json并根据需要进行修改。 有关更多信息，请参见“配置”部分。 如果您使用的是nginx，请复制gochan-http.nginx或g
go chan
weixin_55447336的博客
01-13 274
go 语言天然支持并发，可以通过简单的开启轻量的协程到达，但是多个goruting之间是怎样通信呢，常用的通信模块有共享内存，管道，消息队列通信，Go依赖于成为CSP的并发模型，channel 作为go的一种类似管道，通过它可以在goroutine之间发送和接收消息。通过Channel实现这种同步模式它是Golang在语言层面提供的goroutine间的通信方式。 基本使用 1.声明和创建 ch := make(chan elemType ,cap) //初始化 var ch1 ...
go中的chan
g1607058603的专栏
12-07 585
go中的chan
Go-chan 那些事
galoiszhou的博客
02-07 263
通道中没有数据, 接收数据会阻塞, 可以用第二个参数解决 发送超过通道容量会阻塞 select 没有 default 会阻塞, 有 default 不会阻塞 select 语句最多只会有一个 case 命中 通道关闭了, 可以收数据, 不可以发数据 上代码, 自己品: package main import "fmt" func main() { ch := make(chan int) // 无缓存通道 // 阻塞在发送语句 ch <- 2 // fatal error: all g.
Go语言基础讲解.pdf
09-26
Go语言基础讲解 Go语言是一种静态编译、垃圾回收、并发支持的系统编程语言，由Google公司开发。Go语言旨在创造一门具有高性能和高效开发之间的良好平衡点的编程语言。 Go语言的主要特点： * 类型安全和内存安全 *...
GO语言关键字chan
07-28
引用\[1\]中提到，GO语言关键字"chan"用于定义通道（channel）。通道是一种用于在协程（goroutine）之间传递数据的机制，类似于消息队列。在GO语言中，可以使用关键字"chan"来声明通道变量，例如"var ch chan string...
基础的Go语言教程，适合初学者入门
最新发布
05-01
### 基础的Go语言教程知识点总结 #### 一、Go语言简介 - **定义与特点**：Go语言，也称作Golang，是一种由Google设计并开发的静态类型、编译型的编程语言。它以简洁、高效、安全为特点。 - **适用领域**：适用于...
go chan 学习
muqian328的博客
05-23 227
chan 用于不同线程通信，下面是学习范例package main import ( "fmt" "time" ) func main(){ ////教学1：线程 //go fmt.Println("6") //fmt.Println("7") //time.Sleep(1 * time.Second)//防止子线程没执行完 ////教学2：匿名函数...
go chan简单使用
python基础
03-01 9353
chan在go中是一个通道有可读可写的chan,也存在只读只写的chan,通过共享内存而实现通信 chan 注意点： 在关闭chan后再关闭chan 会出现panic 关闭chan后可以继续进行取值，取完后可以再取但都是对应类型的0值。 可以通过 v,ok:=<-ch 来判断是否取完了 取完了ok为false 也可以通过for range 来取值 for v：= range ch{ fmt.Printf("the data is %d",v) } for { v,ok:=<-ch i
go chan 设计与实现
rubys_的专栏
01-08 1598
chan底层是hchan结构体。go 语法里面的
深入理解 go chan
rubys007的博客
01-14 1891
go 里面通过chan来实现协程之间的通信，chan大概就是一个协程给另一个协程发送信息的代理。多线程程序执行的时候，因为有 CPU 缓存，然后需要对同一块内存进行并发读写，可能会导致数据竞争的问题。在很多语言中，都提供了锁的机制，来保护一片内存同一时刻只能一个线程操作，比如 java 里面的关键字。go 里面很多情况下，在不同协程之间通信都是使用chan来实现的。进程会有阻塞态、运行态，go 里面的协程也有阻塞的状态，当需要的资源得不到满足的时候就会陷入阻塞。比如等待别的协程往chan。
GO chan缓冲通道
wangqiang9x的博客
03-21 503
非缓冲通道的工作方式是读协程在读取chan时，若读取不到会就会阻塞在那里，直到读取到数据为止。写入也是这样如果没有其它协程读取本次的写入，写入协程也同样会阻塞在这里等待。 这种方式明显降低程序运行的效率，如果能写与读互不阻塞是不是就会快很多呢？ 可不可以相互约定一块空间，我把数据放在指定的地方，读取者也去指定的地方读取，这样我把数据放在那里后立刻就可以去做别的事情。 缓冲chan就可以做这件事情，...
GO语言中chan的理解
高性价比服务器就选：蓝易云
08-16 292
在Go语言中，chan是一种用于在并发编程中进行通信的关键字。它代表了一个通道（channel），可以在不同的goroutine之间传递数据。通过通道，可以在不同的goroutine之间安全地传递数据，实现协程间的同步和协作。通道的发送和接收操作具有阻塞特性，使得并发编程更加简单和可靠。通道提供了同步的特性，当发送操作和接收操作在不同的goroutine中进行时，它们会自动阻塞，直到另一方准备好。通道还可以具有容量，通过在创建通道时指定容量来实现。具有容量的通道可以存储多个元素，而不仅仅是单个元素。
golang chan
Geek猫的专栏
12-11 658
  package main import "fmt" func main() { c := make(chan int, 1) select { case c &lt;- 10 : // 写入chan } select { case c &lt;- 20 : // 写入chan,写不进去就丢弃 default: } value , ok := &lt;-...
【Go语言】深入浅出chan（各种实例场景+分析）
weixin_44938441的博客
12-26 3372
文章目录chan简介问题引入有缓冲通道 chan简介 chan 是go的一个关键字，也就是通道的意思，通道是goroutine之间通信和同步的重要组件，也就是go通过通信来共享内存的猜题 问题引入 先引出一个问题来加深理解： 求1-200每个数的阶乘，要求开启200个goroutine各自执行，并将结果存入同一map中，等全部存入完毕后再遍历 直接定义好map后启动goroutine来操作： var ( maps = make(map[int]int,10) ) func main(){ for
go chan基本使用
心如止水
04-27 1744
怎么理解这个缓冲，我个人的理解是是执行这个chan 操作的时候是否发送阻塞。操作：读和写。读取的时候，我们都应该要是阻塞的，例如我们的socket、的recv函数。当然取决于你设置的是阻塞的套接字还是非阻塞的套接字了。无缓冲的chan，讲究读写对称，也就是你在读的时候会阻塞，看下面这个例子：ch是一个无缓冲的chan,在主线程里面，ch
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值