go通道基于go的并发调度实现,本身并不复杂,go并发调度请看我的这篇文章:go并发调度原理学习

1.channel数据结构
  1. type hchan struct {
  2. qcount uint // 缓冲区中已有元素个数
  3. dataqsiz uint //循环队列容量大小
  4. buf unsafe.Pointer // 缓冲区指针
  5. elemsize uint16 //元素大小
  6. closed uint32 //关闭标记,0没关闭,1关闭
  7. elemtype *_type //数据项类型
  8. sendx uint //发送索引
  9. recvx uint //接收索引
  10. recvq waitq //等待接收排队链表
  11. sendq waitq //等待发送排队链表
  12. lock mutex //锁
  13. }
  14. type waitq struct {
  15. first *sudog
  16. last *sudog
  17. }
 
2.创建channel实现
创建channel实例:
ch := make(chan int, 4)
实现函数:
func makechan(t *chantype, size int64) *hchan
大致实现:
执行上面这行代码会new一个hchan结构,同时创建一个dataqsiz=4的int类型的循环队列,其实就是一个容纳4个元素的数组,就是按顺序往里面写数据,写满之后又从0开始写,这个顺序索引就是hchan.sendx
 
3.发送数据
发送数据实例:
ch <- 100
发送数据实现函数:
func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool
ep指向要发送数据的首地址
  1. func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
  2. lock(&c.lock)
  3. if c.closed != {
  4. unlock(&c.lock)
  5. panic(plainError("send on closed channel"))
  6. }
  7.  
  8. if sg := c.recvq.dequeue(); sg != nil {
  9. //缓冲区就是一个固定长度的循环列表
  10. //发送队列是一个双向链表,接在缓冲区的后面,整体是一个队列,保证先进先出
  11. //有接收者,并不是将当前要发送的数据直接发出,而是将缓冲区的第一个元素发送给接收者,同时将发送队列的第一个元素加入缓冲区刚出队列的位置
  12. send(c, sg, ep, func() { unlock(&c.lock) }, )
  13. return true
  14. }
  15.  
  16. if c.qcount < c.dataqsiz {
  17. //缓冲区没有满,直接将要发送的数据复制到缓冲区,直接返回,
  18. qp := chanbuf(c, c.sendx)
  19. typedmemmove(c.elemtype, qp, ep)
  20. c.sendx++
  21. if c.sendx == c.dataqsiz {
  22. c.sendx =
  23. }
  24. c.qcount++
  25. unlock(&c.lock)
  26. return true
  27. }
  28.  
  29. if !block {
  30. unlock(&c.lock)
  31. return false
  32. }
  33. //以上都是同步非阻塞的,ch <- 100直接返回
  34.  
  35. //以下是同步阻塞
  36. //缓冲区满了,也没有接收者,通道将被阻塞,其实就是不执行当前G了,将状态改成等待状态
  37. gp := getg()
  38. mysg := acquireSudog()
  39. c.sendq.enqueue(mysg)
  40. goparkunlock(&c.lock, "chan send", traceEvGoBlockSend, )
  41.  
  42. //当G被唤醒,状态改成可执行状态,从这里开始继续执行
  43. releaseSudog(mysg)
  44. return true
  45. }
大致实现:
1:接收队列不为空,从接收队列中取出第一个接收者*sudog,将数据复制到sudog.elem,复制函数为memmove用汇编实现,通知接收方数据给你了,将接收方协程由等待状态改成可运行状态,将当前协程加入协程队列,等待被调度。
2:没有接收者,有缓冲区且没有满,直接将数据复制到缓冲中,写入缓冲区的位置为hchan.buf[sendx++],如果缓冲区已满sendx=0,就是循环队列的实现,往sendx指定的位置写数据,hchan.qcount++
3:没有接收者,没有缓冲区或是满了,则从当前协程对应的P的sudog队列中取一个struct sudog,将数据复制到sudog.elem,将sudog加入sendq队列中,通知接收方,当前流程阻塞,等待被唤醒,接收方收到通知后(被唤醒),继续往下执行,接收数据完成后会通知发送方,即将发送方协程状态由等待状态改成可运行状态,加入协程可运行队列,等着被执行不会阻塞的情况:
1:通道缓冲区没有满之前,因为只是将要发送的数据复制到缓冲区就返回了
2:有接收者的情况,有数据复制到接收方的数据结构中(不是最终接收数据的变量,在执行接收函数的时候会拷贝到最终接收数据的变量),唤醒接收协程会阻塞的情况:自然就是缓冲区满了,也没有接收方,这个时候会将数据打包放到发送队列,当前协程被设置成等待状态,这个状态不会被调度,当有接收方收到数据后,才会被唤醒
 
4.接收数据
接收数据实例:
val := <- ch
接收数据实现函数:
  1. func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool)
  2. func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
  3. lock(&c.lock)
  4. if sg := c.sendq.dequeue(); sg != nil {
  5. // Found a waiting sender. If buffer is size 0, receive value
  6. // directly from sender. Otherwise, receive from head of queue
  7. // and add sender's value to the tail of the queue (both map to
  8. // the same buffer slot because the queue is full).
  9. recv(c, sg, ep, func() { unlock(&c.lock) }, )
  10. return true, true
  11. }
  12.  
  13. if c.qcount > {
  14. // Receive directly from queue
  15. qp := chanbuf(c, c.recvx)
  16. if ep != nil {
  17. typedmemmove(c.elemtype, ep, qp)
  18. }
  19. typedmemclr(c.elemtype, qp)
  20. c.recvx++
  21. if c.recvx == c.dataqsiz {
  22. c.recvx =
  23. }
  24. c.qcount--
  25. unlock(&c.lock)
  26. return true, true
  27. }
  28.  
  29. if !block {
  30. unlock(&c.lock)
  31. return false, false
  32. }
  33. //以上同步非阻塞
  34.  
  35. //以下同步阻塞
  36. gp := getg()
  37. mysg := acquireSudog()
  38. c.recvq.enqueue(mysg)
  39. //将当前G状态改成等待状态,停止调度
  40. goparkunlock(&c.lock, "chan receive", traceEvGoBlockRecv, )
  41.  
  42. //当前G被唤醒从这里继续执行
  43. mysg.c = nil
  44. releaseSudog(mysg)
  45. return true, !closed
  46. }
大致实现:
1.发送队列不为空(说明缓冲区已满),从发送队列中取出第一个发送者*sudog
1.1.没有缓冲区,直接将发送队列中的数据sudog.elem复制出来,存到接收数据的变量val中,通知发送方我处理完了,你可以继续执行
1.2.有缓冲区,复制出缓冲区hchan.buf[recvx]对应的元素到val,在将发送方sudog.elem复制到hchan.buf[recvx],发送方按顺序写,接收方按顺序读,典型的FIFO,为了保证是先进先出,所以先复制出,再将队列首元素复制到对应的缓冲区中,其实就是发送队列连接在缓冲区后面,缓冲区满了,就写队列,接收的时候先从缓冲区中拿数据,拿掉之后空出来的位置从发送队列中取第一个填满,并唤醒对应的G,只要发送队列不为空,缓冲区肯定会被填满
2.发送队列为空,缓冲区不为空,复制出缓冲区hchan.buf[recvx]对应的元素到val,hchan.qcount--
3.发送队列为空,缓冲区也为空,那就是没有任何待接收的数据,接收流程就只能等了,将接收信息打包成sudog,加入接收队列recvq,当前执行流程阻塞,等有发送数据后会被唤醒继续
 
5.channel FIFO在解释一次
5.1:缓冲区没满,发送数据就是进缓冲队列,接收数据就是出缓冲队列,比较好理解
5.2:缓冲区已满,发送数据就是进等待队列,接收数据先出缓冲队列,即为要接收的数据,等待队列出列,将数据存在缓冲队列刚出列的位置,刚出列的位置相当于缓冲队列的末尾,也就是说等待队列的列头连在缓冲队列的末尾,将等待队列的列头加入缓存队列的列尾,保证了缓冲队列是满的,减少的是缓冲队列中的数据,保证先进先出
5.3:接收数据,缓冲队列或等待队列有数据,拿走第一个,保证等待队列是接在缓冲区末尾,即缓冲区末尾有空缺,就让等待队列出列,并填充至缓冲区末尾,否则将自己打包加入接收队列,当前G进入等待状态,有数据发送自然会通知你
 
总结:Go channel基于go的并发调度实现阻塞和非阻塞两种通讯方式
 

Go channel实现源码分析的更多相关文章

  1. Netty源码分析第1章(Netty启动流程)---->第3节: 服务端channel初始化

    Netty源码分析第一章:Netty启动流程   第三节:服务端channel初始化 回顾上一小节的initAndRegister()方法: final ChannelFuture initAndRe ...

  2. NIO 源码分析(05) Channel 源码分析

    目录 一.Channel 类图 二.begin 和 close 是什么 2.1 AbstractInterruptibleChannel 中的 begin 和 close 2.2 Selector 中 ...

  3. zookeeper源码分析之三客户端发送请求流程

    znode 可以被监控,包括这个目录节点中存储的数据的修改,子节点目录的变化等,一旦变化可以通知设置监控的客户端,这个功能是zookeeper对于应用最重要的特性,通过这个特性可以实现的功能包括配置的 ...

  4. MyCat源码分析系列之——前后端验证

    更多MyCat源码分析,请戳MyCat源码分析系列 MyCat前端验证 MyCat的前端验证指的是应用连接MyCat时进行的用户验证过程,如使用MySQL客户端时,$ mysql -uroot -pr ...

  5. gRPC源码分析0-导读

    gRPC是Google开源的新一代RPC框架,官网是http://www.grpc.io.正式发布于2016年8月,技术栈非常的新,基于HTTP/2,netty4.1,proto3.虽然目前在工程化方 ...

  6. dubbo源码分析6-telnet方式的管理实现

    dubbo源码分析1-reference bean创建 dubbo源码分析2-reference bean发起服务方法调用 dubbo源码分析3-service bean的创建与发布 dubbo源码分 ...

  7. docker 源码分析 四(基于1.8.2版本),Docker镜像的获取和存储

    前段时间一直忙些其他事情,docker源码分析的事情耽搁了,今天接着写,上一章了解了docker client 和 docker daemon(会启动一个http server)是C/S的结构,cli ...

  8. 最新版ffmpeg源码分析

    最新版ffmpeg源码分析一:框架 (ffmpeg v0.9) 框架 最新版的ffmpeg中发现了一个新的东西:avconv,而且ffmpeg.c与avconv.c一个模样,一研究才发现是libav下 ...

  9. Java IO 之 FileInputStream & FileOutputStream源码分析

    Writer      :BYSocket(泥沙砖瓦浆木匠) 微         博:BYSocket 豆         瓣:BYSocket FaceBook:BYSocket Twitter   ...

随机推荐

  1. Windows上安装配置SSH教程(2)——在Windows XP和Windows 10上安装并配置OpenSSH for Windows

    知识点汇总:http://www.cnblogs.com/feipeng8848/p/8559803.html ------------------------ 安装方式有3种: (1)Windows ...

  2. jackson json转对象 json转集合 对大小写支持

    @JsonAutoDetect(fieldVisibility = Visibility.ANY, getterVisibility = Visibility.NONE, isGetterVisibi ...

  3. 利用face_recognition库裁取人脸

    from PIL import Image import face_recognition # Load the jpg file into a numpy array image = face_re ...

  4. Android 7.0 存储系统—Vold与MountService分析(一)(转 Android 9.0 分析)

    Android的存储系统(一) 看了很长时间Vold存储模块的相关知识,也死扣了一段时间的Android源码,发现Android存储系统所涉及的函数调用,以及Kernel与上层之间的Socket传输真 ...

  5. es6学习笔记-proxy对象

    前提摘要 尤大大的vue3.0即将到来,虽然学不动了,但是还要学的啊,据说vue3.0是基于proxy来进行对值进行拦截并操作,所以es6的proxy也是要学习一下的. 一 什么是proxy Prox ...

  6. 【重学计算机】操作系统D6章:并发程序设计

    1. 并发程序的基本概念 程序顺序性 内部顺序性:CPU严格按照顺序执行指令 外部顺序性:程序员设计程序时往往用顺序设计的思想 顺序程序特性 程序执行的顺序性 计算环境的封闭性: 程序执行时犹如独占资 ...

  7. Ubuntu命令用法详解——curl命令

    简介: cURL(CommandLine Uniform Resource Locator)是一个利用URL语法在命令行下工作的文件传输工具,1997年首次发行.它支持文件上传和下载,所以是综合传输工 ...

  8. WebApi管理和性能测试工具WebApiBenchmarks

    说到WebApi管理和测试工具其实已经非常多的了,Postman.Swagger等在管理和维护上都非常出色:在性能测试方面也有不少的工具如:wrk,bombardier,http_load和ab等等. ...

  9. 前端笔记之NodeJS(二)路由&REPL&模块系统&npm

    一.路由机制(静态资源文件处理) 1.1 Nodejs没有根目录 MIME类型:http://www.w3school.com.cn/media/media_mimeref.asp 在Apache中, ...

  10. 关于vue使用form上传文件

    在vue中使用form表单上传文件文件的时候出现了一些问题,获取文件的时候一直返回null, 解决之后又出现发送到后台的file文件后台显示为空,解决源码 <template> <d ...