锐客网

  1. 首页 > 生活百科 > it技术 > >

go语言chan例子 go语言原理

channelIT技术

Golang入门到项目实战 | golang并发变成之通道channel Go提供了一种称为通道的机制，用于在goroutine之间共享数据 。当您作为goroutine执行并发活动时，需要在goroutine之间共享资源或数据，通道充当goroutine之间的管道（管道）并提供一种机制来保证同步交换 。
根据数据交换的行为，有两种类型的通道：无缓冲通道和缓冲通道 。无缓冲通道用于执行goroutine之间的同步通信，而缓冲通道用于执行异步通信 。无缓冲通道保证在发送和接收发生的瞬间两个goroutine之间的交换 。缓冲通道没有这样的保证 。
通道由make函数创建，该函数指定chan关键字和通道的元素类型 。
这是创建无缓冲和缓冲通道的代码块：
语法
使用内置函数make创建无缓冲和缓冲通道 。make的第一个参数需要关键字chan，然后是通道允许交换的数据类型 。
这是将值发送到通道的代码块需要使用-运算符：
语法
一个包含5个值的缓冲区的字符串类型的goroutine1通道 。然后我们通过通道发送字符串“Australia” 。
这是从通道接收值的代码块：
语法
- 运算符附加到通道变量（goroutine1）的左侧 ， 以接收来自通道的值 。
在无缓冲通道中 ， 在接收到任何值之前没有能力保存它 。在这种类型的通道中，发送和接收goroutine在任何发送或接收操作完成之前的同一时刻都准备就绪 。如果两个goroutine没有在同一时刻准备好，则通道会让执行其各自发送或接收操作的goroutine首先等待 。同步是通道上发送和接收之间交互的基础 。没有另一个就不可能发生 。
【go语言chan例子 go语言原理】 在缓冲通道中，有能力在接收到一个或多个值之前保存它们 。在这种类型的通道中，不要强制goroutine在同一时刻准备好执行发送和接收 。当发送和接收阻塞时也有不同的条件 。只有当通道中没有要接收的值时，接收才会阻塞 。仅当没有可用缓冲区来放置正在发送的值时 ， 发送才会阻塞 。
实例
运行结果
Go语言基础语法（一）本文介绍一些Go语言go语言chan例子的基础语法 。
先来看一个简单的go语言代码go语言chan例子：
go语言的注释方法：
代码执行结果：
下面来进一步介绍go的基础语法 。
go语言中格式化输出可以使用 fmt 和 log 这两个标准库go语言chan例子，
常用方法：
示例代码：
执行结果：
更多格式化方法可以访问中的fmt包 。
log包实现go语言chan例子了简单的日志服务，也提供了一些格式化输出的方法 。
执行结果：
下面来介绍一下go的数据类型
下表列出了go语言的数据类型：
int、float、bool、string、数组和struct属于值类型，这些类型的变量直接指向存在内存中的值go语言chan例子；slice、map、chan、pointer等是引用类型，存储的是一个地址，这个地址存储最终的值 。
常量是在程序编译时就确定下来的值 ， 程序运行时无法改变 。
执行结果：
执行结果：
Go 语言的运算符主要包括算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符以及指针相关运算符 。
算术运算符：
关系运算符：
逻辑运算符：
位运算符：
赋值运算符：
指针相关运算符：
下面介绍一下go语言中的if语句和switch语句 。另外还有一种控制语句叫select语句，通常与通道联用，这里不做介绍 。
if语法格式如下：
if ... else ：
else if：
示例代码：
语法格式：
另外 ， 添加 fallthrough 会强制执行后面的 case 语句 ， 不管下一条case语句是否为true 。
示例代码：
执行结果：
下面介绍几种循环语句：
执行结果：
执行结果：
也可以通过标记退出循环：
--THE END--
Golang 语言深入理解：channel 本文是对 Gopher 2017 中一个非常好的 Talk?: [Understanding Channel](GopherCon 2017: Kavya Joshi - Understanding Channels) 的学习笔记，希望能够通过对 channel 的关键特性的理解，进一步掌握其用法细节以及 Golang 语言设计哲学的管窥蠡测 。
channel是可以让一个 goroutine 发送特定值到另一个 gouroutine 的通信机制 。
原生的 channel 是没有缓存的(unbuffered channel)，可以用于 goroutine 之间实现同步 。
关闭后不能再写入，可以读取直到 channel 中再没有数据，并返回元素类型的零值 。
gopl/ch3/netcat3
首先从 channel 是怎么被创建的开始:
在 heap 上分配一个 hchan 类型的对象，并将其初始化，然后返回一个指向这个 hchan 对象的指针 。
理解了 channel 的数据结构实现，现在转到 channel 的两个最基本方法:sends和receivces，看一下以上的特性是如何体现在sends和receives中的:
假设发送方先启动，执行 ch - task0 :
如此为 channel 带来了goroutine-safe 的特性 。
在这样的模型里，sender goroutine - channel - receiver goroutine之间，hchan 是唯一的共享内存，而这个唯一的共享内存又通过 mutex 来确保 goroutine-safe，所有在队列中的内容都只是副本 。
这便是著名的 golang 并发原则的体现:
发送方 goroutine 会阻塞，暂停，并在收到 receive 后才恢复 。
goroutine 是一种 用户态线程 , 由 Go runtime 创建并管理 ， 而不是操作系统，比起操作系统线程来说，goroutine更加轻量 。
Go runtime scheduler 负责将 goroutine 调度到操作系统线程上 。
runtime scheduler 怎么将 goroutine 调度到操作系统线程上？
当阻塞发生时，一次 goroutine 上下文切换的全过程:
然而，被阻塞的 goroutine 怎么恢复过来？
阻塞发生时，调用 runtime sheduler 执行 gopark 之前，G1 会创建一个 sudog，并将它存放在 hchan 的 sendq 中 。sudog 中便记录了即将被阻塞的 goroutineG1，以及它要发送的数据元素 task4 等等 。
接收方 将通过这个 sudog 来恢复 G1
接收方 G2 接收数据, 并发出一个 receivce，将 G1 置为runnable :
同样的, 接收方 G2 会被阻塞，G2 会创建 sudoq，存放在 recvq ，基本过程和发送方阻塞一样 。
不同的是，发送方 G1如何恢复接收方 G2，这是一个非常神奇的实现 。
理论上可以将 task 入队，然后恢复 G2, 但恢复 G2后，G2会做什么呢？
G2会将队列中的 task 复制出来，放到自己的 memory 中，基于这个思路 ， G1在这个时候，直接将 task 写到 G2的 stack memory 中！
这是违反常规的操作，理论上 goroutine 之间的 stack 是相互独立的，只有在运行时可以执行这样的操作 。
这么做纯粹是出于性能优化的考虑，原来的步骤是：
优化后 ， 相当于减少了 G2 获取锁并且执行 memcopy 的性能消耗 。
channel 设计背后的思想可以理解为 simplicity 和 performance 之间权衡抉择 ， 具体如下：
queue with a lock prefered to lock-free implementation:
比起完全 lock-free 的实现，使用锁的队列实现更简单，容易实现
Go小技巧（二）— 打开已经关闭的channel有时候我们需要在完全可控的范围内复用channel，但是关闭了的channel原生语法并没有提供方法打开，所以利用指针再次打开 。
channel的结构体在 chan.go 中：
Channel是否关闭取决于 hchan.closed ，0是打开 ， 1是关闭 。
方法：让指针指向 hchan.closed 直接修改它的值 。
closedOffset为什么是28呢？这个涉及到struct对齐问题，Go内存优化（一）— struct对齐
在上面主要用了指针定位closed值 ， 直接修改标志位 。为了保证设置closed值的安全性所以在给它设置值的时候使用runtime.lock上锁 。
关于 go:linkname 可以自行百度 ， 在目录下创建一个 *.s 文件可以躲过编译时error： missing function body。
Go 语言内存管理（三）：逃逸分析Go 语言较之 C 语言一个很大的优势就是自带 GC 功能 ， 可 GC 并不是没有代价的 。写 C 语言的时候，在一个函数内声明的变量，在函数退出后会自动释放掉，因为这些变量分配在栈上 。如果你期望变量的数据可以在函数退出后仍然能被访问，就需要调用malloc方法在堆上申请内存，如果程序不再需要这块内存了 ， 再调用free方法释放掉 。Go 语言不需要你主动调用malloc来分配堆空间，编译器会自动分析，找出需要malloc的变量，使用堆内存 。编译器的这个分析过程就叫做逃逸分析 。
所以你在一个函数中通过dict := make(map[string]int)创建一个 map 变量，其背后的数据是放在栈空间上还是堆空间上，是不一定的 。这要看编译器分析的结果 。
可逃逸分析并不是百分百准确的，它有缺陷 。有的时候你会发现有些变量其实在栈空间上分配完全没问题的，但编译后程序还是把这些数据放在了堆上 。如果你了解 Go 语言编译器逃逸分析的机制，在写代码的时候就可以有意识地绕开这些缺陷，使你的程序更高效 。
Go 语言虽然在内存管理方面降低了编程门槛，即使你不了解堆栈也能正常开发，但如果你要在性能上较真的话，还是要掌握这些基础知识 。
这里不对堆内存和栈内存的区别做太多阐述 。简单来说就是 ， 栈分配廉价，堆分配昂贵 。栈空间会随着一个函数的结束自动释放，堆空间需要时间 GC 模块不断地跟踪扫描回收 。如果对这两个概念有些迷糊，建议阅读下面 2 个文章：
这里举一个小例子 ， 来对比下堆栈的差别：
stack函数中的变量i在函数退出会自动释放；而heap函数返回的是对变量i的引用，也就是说heap()退出后，表示变量i还要能被访问，它会自动被分配到堆空间上 。
他们编译出来的代码如下：
逻辑的复杂度不言而喻，从上面的汇编中可看到 ， heap()函数调用了runtime.newobject()方法，它会调用mallocgc方法从mcache上申请内存，申请的内部逻辑前面文章已经讲述过 。堆内存分配不仅分配上逻辑比栈空间分配复杂，它最致命的是会带来很大的管理成本，Go 语言要消耗很多的计算资源对其进行标记回收（也就是 GC 成本） 。
Go 编辑器会自动帮我们找出需要进行动态分配的变量，它是在编译时追踪一个变量的生命周期，如果能确认一个数据只在函数空间内访问，不会被外部使用，则使用栈空间，否则就要使用堆空间 。
我们在go build编译代码时，可使用-gcflags '-m'参数来查看逃逸分析日志 。
以上面的两个函数为例 ， 编译的日志输出是：
日志中的i escapes to heap表示该变量数据逃逸到了堆上 。
需要使用堆空间，所以逃逸，这没什么可争议的 。但编译器有时会将不需要使用堆空间的变量，也逃逸掉 。这里是容易出现性能问题的大坑 。网上有很多相关文章，列举了一些导致逃逸情况，其实总结起来就一句话：
多级间接赋值容易导致逃逸。
这里的多级间接指的是，对某个引用类对象中的引用类成员进行赋值 。Go 语言中的引用类数据类型有func,interface,slice,map,chan,*Type(指针)。
记住公式Data.Field = Value，如果Data,Field都是引用类的数据类型，则会导致Value逃逸 。这里的等号=不单单只赋值，也表示参数传递 。
根据公式，我们假设一个变量data是以下几种类型，相应的可以得出结论：
下面给出一些实际的例子：
如果变量值是一个函数，函数的参数又是引用类型 ， 则传递给它的参数都会逃逸 。
上例中te的类型是func(*int) ， 属于引用类型，参数*int也是引用类型，则调用te(j)形成了为te的参数(成员)*int赋值的现象，即te.i = j会导致逃逸 。代码中其他几种调用都没有形成 多级间接赋值 情况 。
同理 ， 如果函数的参数类型是slice,map或interface{}都会导致参数逃逸 。
匿名函数的调用也是一样的，它本质上也是一个函数变量 。有兴趣的可以自己测试一下 。
只要使用了Interface类型(不是interafce{})，那么赋值给它的变量一定会逃逸 。因为interfaceVariable.Method()先是间接的定位到它的实际值，再调用实际值的同名方法，执行时实际值作为参数传递给方法 。相当于interfaceVariable.Method.this = realValue
向 channel 中发送数据，本质上就是为 channel 内部的成员赋值，就像给一个 slice 中的某一项赋值一样 。所以chan *Type,chan map[Type]Type,chan []Type,chan interface{}类型都会导致发送到 channel 中的数据逃逸 。
这本来也是情理之中的，发送给 channel 的数据是要与其他函数分享的，为了保证发送过去的指针依然可用 ， 只能使用堆分配 。
可变参数如func(arg ...string)实际与func(arg []string)是一样的，会增加一层访问路径 。这也是fmt.Sprintf总是会使参数逃逸的原因 。
例子非常多，这里不能一一列举，我们只需要记住分析方法就好，即，2 级或更多级的访问赋值会容易导致数据逃逸 。这里加上容易二字是因为随着语言的发展，相信这些问题会被慢慢解决，但现阶段，这个可以作为我们分析逃逸现象的依据 。
下面代码中包含 2 种很常规的写法，但他们却有着很大的性能差距，建议自己想下为什么 。
Benchmark 和 pprof 给出的结果:
熟悉堆栈概念可以让我们更容易看透 Go 程序的性能问题，并进行优化 。
多级间接赋值会导致 Go 编译器出现不必要的逃逸，在一些情况下可能我们只需要修改一下数据结构就会使性能有大幅提升 。这也是很多人不推荐在 Go 中使用指针的原因 ， 因为它会增加一级访问路径，而map,slice,interface{}等类型是不可避免要用到的，为了减少不必要的逃逸，只能拿指针开刀了 。
大多数情况下，性能优化都会为程序带来一定的复杂度 。建议实际项目中还是怎么方便怎么写，功能完成后通过性能分析找到瓶颈所在，再对局部进行优化 。
golang - channel通过var声明或者make函数创建的channel变量是一个存储在函数栈帧上的指针，占用8个字节 ， 指向堆上的hchan结构体
源码包中src/runtime/chan.go定义了hchan的数据结构如下：
hchan结构体的主要组成部分有四个：
用来保存goroutine之间传递数据的循环数组：buf
用来记录此循环数组当前发送或接收数据的下标值：sendx和recvx
用于保存向该chan发送和从该chan接收数据被阻塞的goroutine队列： sendq 和 recvq
保证channel写入和读取数据时线程安全的锁：lock
环形数组作为channel 的缓冲区 数组的长度就是定义channnel 时channel 的缓冲大小
在hchan 中包括了读/写 等待队列，waitq是一个双向队列，包括了一个头结点和尾节点 。每个节点是一个sudog结构体变量
channel有2种类型：无缓冲、有缓冲，在创建时 make(chan type cap)通过cap 设定缓冲大小
channel有3种模式：写操作模式（单向通道）、读操作模式（单向通道）、读写操作模式（双向通道）
channel有3种状态：未初始化、正常、关闭
如下几种状态会引发panic
channel 是线程安全的，channel的底层实现中，hchan结构体中采用Mutex锁来保证数据读写安全 。在对循环数组buf中的数据进行入队和出队操作时 ， 必须先获取互斥锁，才能操作channel数据
go语言chan例子的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于go语言原理、go语言chan例子的信息别忘了在本站进行查找喔 。

    推荐阅读


    上一篇：如何在网上运营电商，如何成功运营电子商务网站

    下一篇：为什么红包服务器总是繁忙？ 红包服务器繁忙怎么回事