1.从项目的一个 panic 说起：Go 中 Sync 包的分析应用
2.golang：context介绍
3.图解Go里面的WaitGroup了解编程语言核心实现源码
4.Go并发实战--sync WaitGroup
5.基于 Golang 实现的 Shadowsocks 源码解析
6.Go并发编程：goroutine，channel和sync详解

从项目的一个 panic 说起：Go 中 Sync 包的分析应用

       在项目开发过程中，遇到一个常见的错误——"fatal error: concurrent map read and map write"，这是由于Golang内建的map在并发环境下不安全导致的。解决这个问题的方法并不复杂，就是转向使用sync包提供的并发安全的map。

       sync包在Golang 1.9之后被官方支持，sfr源码其中包含了丰富的同步原语，是并发编程的关键部分。在Golang 1.9之前，解决map并发问题通常会借助sync包中的sync.RWMutex或其他锁机制。Golang作为支持用户态进程的编程语言，对并发编程的处理自然离不开锁，这是一种确保多个Goroutine在同一片内存中协同工作的同步机制。

       sync包的源码目录结构清晰，包含Mutex、RWmutex、WaitGroup、Map、补码和源码转化Once、Cond、Pool等组件。接下来，我们将逐个分析这些同步原语的用途和使用注意事项，重点讨论在项目中常见的sync.Map。

       sync.Map是sync包中的一种高效并发安全的map实现，与内建map相比，它提供了Load、Store、LoadOrStore、Delete和Range等方法，并且具有更高的并发性能。虽然sync.Map没有len方法，但其内部机制使得在并发环境中的操作更加稳健。

       通过结合实际项目案例和面试题中的陷阱，本文简要探讨了sync包中Mutex、游击涨停个股源码RWMutex、WaitGroup、Once以及Map的使用技巧和注意事项。在实际编程中，正确使用这些同步原语对于避免并发问题至关重要。

golang：context介绍

       1 前言

       æœ€è¿‘实现系统的分布式日志与事务管理时,在寻求所谓的全局唯一Goroutine ID无果之后,决定还是简单利用Context机制实现了基本的想法,不够高明,但是好用.于是对它当初的设计比较好奇,便有了此文.

       Context是golang官方定义的一个package,它定义了Context类型,里面包含了Deadline/Done/Err方法以及绑定到Context上的成员变量值Value,具体定义如下：

typeContextinterface{ //返回Context的超时时间（超时返回场景）Deadline()(deadlinetime.Time,okbool)//在Context超时或取消时（即结束了）返回一个关闭的channel//即如果当前Context超时或取消时,Done方法会返回一个channel,然后其他地方就可以通过判断Done方法是否有返回（channel）,如果有则说明Context已结束//故其可以作为广播通知其他相关方本Context已结束,请做相关处理.Done()<-chanstruct{ }//返回Context取消的原因Err()error//返回Context相关数据Value(keyinterface{ })interface{ }}那么到底什么Context？

       å¯ä»¥å­—面意思可以理解为上下文,比较熟悉的有进程/线程上线文,关于golang中的上下文,一句话概括就是： goroutine的相关环境快照,其中包含函数调用以及涉及的相关的变量值. 通过Context可以区分不同的goroutine请求,因为在golang Severs中,每个请求都是在单个goroutine中完成的.

       æœ€è¿‘在公司分析gRPC源码,proto文件生成的代码,接口函数第一个参数统一是ctx context.Context接口,公司不少同事都不了解这样设计的出发点是什么,其实我也不了解其背后的原理.今天趁着妮妲台风妹子正面登陆深圳,全市停工,停课,停业,在家休息找了一些资料研究把玩一把.

       Context通常被译作上下文,它是一个比较抽象的概念.在公司技术讨论时也经常会提到上下文.一般理解为程序单元的一个运行状态,现场,快照,而翻译中上下又很好地诠释了其本质,上下上下则是存在上下层的传递,上会把内容传递给下.在Go语言中,程序单元也就指的是Goroutine.

       æ¯ä¸ªGoroutine在执行之前,都要先知道程序当前的执行状态,通常将这些执行状态封装在一个Context变量中,传递给要执行的Goroutine中. 上下文则几乎已经成为传递与请求同生存周期变量的标准方法.在网络编程下,当接收到一个网络请求Request,处理Request时,我们可能需要开启不同的Goroutine来获取数据与逻辑处理,即一个请求Request,会在多个Goroutine中处理. 而这些Goroutine可能需要共享Request的一些信息;同时当Request被取消或者超时的时候,所有从这个Request创建的所有Goroutine也应该被结束.

       æ³¨ï¼šå…³äºŽgoroutine的理解可以移步这里.

2 为什么使用context

       ç”±äºŽåœ¨golang severs中,每个request都是在单个goroutine中完成,并且在单个goroutine（不妨称之为A）中也会有请求其他服务（启动另一个goroutine（称之为B）去完成）的场景,这就会涉及多个Goroutine之间的调用.如果某一时刻请求其他服务被取消或者超时,则作为深陷其中的当前goroutine B需要立即退出,然后系统才可回收B所占用的资源. 即一个request中通常包含多个goroutine,这些goroutine之间通常会有交互.

       é‚£ä¹ˆ,如何有效管理这些goroutine成为一个问题（主要是退出通知和元数据传递问题）,Google的解决方法是Context机制,相互调用的goroutine之间通过传递context变量保持关联,这样在不用暴露各goroutine内部实现细节的前提下,有效地控制各goroutine的运行.

       å¦‚此一来,通过传递Context就可以追踪goroutine调用树,并在这些调用树之间传递通知和元数据. 虽然goroutine之间是平行的,没有继承关系,但是Context设计成是包含父子关系的,这样可以更好的描述goroutine调用之间的树型关系.

3 怎么使用context

       ç”Ÿæˆä¸€ä¸ªContext主要有两类方法：

3.1 顶层Context：Background

       è¦åˆ›å»ºContext树,首先就是要创建根节点

//返回一个空的Context,它作为所有由此继承Context的根节点funcBackground()Context

       è¯¥Context通常由接收request的第一个goroutine创建,它不能被取消,没有值,也没有过期时间,常作为处理request的顶层context存在.

3.2 下层Context：WithCancel/WithDeadline/WithTimeout

       æœ‰äº†æ ¹èŠ‚点之后,接下来就是创建子孙节点.为了可以很好的控制子孙节点,Context包提供的创建方法均是带有第二返回值（CancelFunc类型）,它相当于一个Hook,在子goroutine执行过程中,可以通过触发Hook来达到控制子goroutine的目的（通常是取消,即让其停下来）.再配合Context提供的Done方法,子goroutine可以检查自身是否被父级节点Cancel：

select{ case<-ctx.Done()://dosomeclean…}

       æ³¨ï¼šçˆ¶èŠ‚点Context可以主动通过调用cancel方法取消子节点Context,而子节点Context只能被动等待.同时父节点Context自身一旦被取消（如其上级节点Cancel）,其下的所有子节点Context均会自动被取消.

       æœ‰ä¸‰ç§åˆ›å»ºæ–¹æ³•ï¼š

//带cancel返回值的Context,一旦cancel被调用,即取消该创建的contextfuncWithCancel(parentContext)(ctxContext,cancelCancelFunc)//带有效期cancel返回值的Context,即必须到达指定时间点调用的cacel方法才会被执行funcWithDeadline(parentContext,deadlinetime.Time)(Context,CancelFunc)//带超时时间cancel返回值的Context,类似Deadline,前者是时间点,后者为时间间隔//相当于WithDeadline(parent,time.Now().Add(timeout)).funcWithTimeout(parentContext,timeouttime.Duration)(Context,CancelFunc)

       ä¸‹é¢æ¥çœ‹æ”¹ç¼–自Advanced Go Concurrency Patterns视频提供的一个简单例子：

packagemainimport("context""fmt""time")funcsomeHandler(){ //创建继承Background的子节点Contextctx,cancel:=context.WithCancel(context.Background())godoSth(ctx)//模拟程序运行-Sleep5秒time.Sleep(5*time.Second)cancel()}//每1秒work一下,同时会判断ctx是否被取消,如果是就退出funcdoSth(ctxcontext.Context){ vari=1for{ time.Sleep(1*time.Second)select{ case<-ctx.Done():fmt.Println("done")returndefault:fmt.Printf("work%dseconds:\n",i)}i++}}funcmain(){ fmt.Println("start...")someHandler()fmt.Println("end.")}

       è¾“出结果：

       æ³¨æ„,此时doSth方法中case之done的fmt.Println("done")并没有被打印出来.

       è¶…时场景：

packagemainimport("context""fmt""time")functimeoutHandler(){ //创建继承Background的子节点Contextctx,cancel:=context.WithTimeout(context.Background(),3*time.Second)godoSth(ctx)//模拟程序运行-Sleep秒time.Sleep(*time.Second)cancel()//3秒后将提前取消doSthgoroutine}//每1秒work一下,同时会判断ctx是否被取消,如果是就退出funcdoSth(ctxcontext.Context){ vari=1for{ time.Sleep(1*time.Second)select{ case<-ctx.Done():fmt.Println("done")returndefault:fmt.Printf("work%dseconds:\n",i)}i++}}funcmain(){ fmt.Println("start...")timeoutHandler()fmt.Println("end.")}

       è¾“出结果：

4 context是一个优雅的设计吗?

       ç¡®å®ž,通过引入Context包,一个request范围内所有goroutine运行时的取消可以得到有R效的控制.但是这种解决方式却不够优雅.

4.1 context 像病毒一样扩散

       ä¸€æ—¦ä»£ç ä¸­æŸå¤„用到了Context,传递Context变量（通常作为函数的第一个参数）会像病毒一样蔓延在各处调用它的地方. 比如在一个request中实现数据库事务或者分布式日志记录, 创建的context,会作为参数传递到任何有数据库操作或日志记录需求的函数代码处. 即每一个相关函数都必须增加一个context.Context类型的参数,且作为第一个参数,这对无关代码完全是侵入式的.

       æ›´å¤šè¯¦ç»†å†…容可参见：Michal Strba 的context-should-go-away-go2文章

       Google Group上的讨论可移步这里.

4.2 Context 不仅仅只是cancel信号

       Context机制最核心的功能是在goroutine之间传递cancel信号,但是它的实现是不完全的.

       Cancel可以细分为主动与被动两种,通过传递context参数,让调用goroutine可以主动cancel被调用goroutine.但是如何得知被调用goroutine什么时候执行完毕,这部分Context机制是没有实现的.而现实中的确又有一些这样的场景,比如一个组装数据的goroutine必须等待其他goroutine完成才可开始执行,这是context明显不够用了,必须借助sync.WaitGroup.

funcserve(lnet.Listener)error{ varwgsync.WaitGroupvarconnnet.Connvarerrerrorfor{ conn,err=l.Accept()iferr!=nil{ break}wg.Add(1)gofunc(cnet.Conn){ deferwg.Done()handle(c)}(conn)}wg.Wait()returnerr}4.3 context.value

       context.Value相当于goroutine的TLS（Thread Local Storage）,但它不是静态类型安全的,任何结构体变量都必须作为字符串形式存储.同时,所有context都会在其中定义变量,很容易造成命名冲突.

5 总结

       context包通过构建树型关系的Context,来达到上一层Goroutine能对传递给下一层Goroutine的控制.对于处理一个Request请求操作,需要采用context来层层控制Goroutine,以及传递一些变量来共享.

       Context对象的生存周期一般仅为一个请求的处理周期.即针对一个请求创建一个Context变量（它为Context树结构的根）;在请求处理结束后,撤销此ctx变量,释放资源.

       æ¯æ¬¡åˆ›å»ºä¸€ä¸ªGoroutine,要么将原有的Context传递给Goroutine,要么创建一个子Context并传递给Goroutine.

       Context能灵活地存储不同类型,不同数目的值,并且使多个Goroutine安全地读写其中的值.

       å½“通过父Context对象创建子Context对象时,可同时获得子Context的一个撤销函数,这样父Context对象的创建环境就获得了对子Context将要被传递到的Goroutine的撤销权.

       åœ¨å­Context被传递到的goroutine中,应该对该子Context的Done信道（channel）进行监控,一旦该信道被关闭（即上层运行环境撤销了本goroutine的执行）,应主动终止对当前请求信息的处理,释放资源并返回.

6 致谢

       pkg/context

       context-should-go-away-go2

       ç†è§£ Go Context 机制

       context-isnt-for-cancellation

       context-is-for-cancelation

       thread-local-a-convenient-abomination

图解Go里面的WaitGroup了解编程语言核心实现源码

       sync.WaitGroup核心实现逻辑简单，主要用于等待一组goroutine退出。它通过Add方法指定等待的goroutine数量，Done方法递减计数。计数为0时，等待结束。sync.WaitGroup内部使用了一个state1数组，其中只有一个元素，类型为[3]uint。这是为了内存对齐，确保数据按照4字节对齐，从而在位和位平台间兼容。单件衣服源码

       内部元素采用uint类型进行计数，长度为8字节。这是为了防止在位平台上对字节的uint操作可能不是原子的情况。使用uint保证了原子操作的执行和性能。在CPU缓存线（cache line）的上下文中，8字节长度可能有助于确保对缓存线的操作是原子的，从而避免数据损坏。

       测试8字节指针的构造，验证了在经过编译器进行内存分配对齐后，如果元素指针的地址不能被8整除，则其地址+4可以被8整除。这展示了编译器层内存对齐的实现细节。

       sync.WaitGroup中的8字节uint采用分段计数的方式，高位记录需要Done的数量，低位记录正在等待结束的计数。

       源码的核心原理包括使用位uint进行计数，通过高位记录需要Done的源码搭建诚信科技数量和低位记录等待的数量。当发现count>0时，Wait的goroutine会排队等待。任务完成后，goroutine执行Done操作，直到count==0，完成并唤醒所有等待的goroutine。

       计数与信号量的实现通过根据当前指针的地址确定采用哪个分段进行计数和等待。添加等待计数和Done完成等待事件分别对应sync.WaitGroup的Add和Done方法。等待所有操作完成时，sync.WaitGroup确保所有任务完成。

       为了深入理解这些概念，可以参考相关文章和资源，如关于CPU缓存线大小和原子操作的讨论。此外，更多源码分析文章可关注特定的公告号或网站，如www.sreguide.com。本篇文章由ArtiPub自动发布平台发布。

Go并发实战--sync WaitGroup

       Go语言并发编程中，sync WaitGroup是一种极其实用的工具，它类似于Java的CyclicBarrier，但作用于协程。在处理并发任务时，WaitGroup可以帮助我们监控一组协程的执行状态，以便决定后续操作。其基本操作包括Add()增加等待数，Done()减少等待数，以及Wait()阻塞协程直到所有任务完成。下面将通过实例和原理深入探讨WaitGroup的使用和工作原理。

       语法基础

       WaitGroup的核心功能体现在Add(), Done(), 和 Wait()三个函数上：

       - Add()：增加等待数，可能加1或加n，它会调整计数器，当计数器为零时，等待的协程会被释放。

       - Done()：相当于Add(-1)，用于减少等待数，确保在返回Wait之前计数器为零。

       - Wait()：阻塞当前协程，直到所有任务完成（即计数器为零）才继续执行。

       例如：

       (代码片段)

实现原理

       WaitGroup的内部实现相当简洁，主要由一个结构体组成，其中包含一个计数器和一个信号量。Add()函数会以原子操作更新计数器，如果计数器减为零，所有等待的goroutine会被释放。需要注意的是：

       - 在创建goroutine或调用Wait之前，必须确保Add()的正增量调用已经完成。

       - 如果重用WaitGroup，每次新的等待事件后，必须先完成之前的Wait调用。

源码解析

       Wait()函数的源码实现了协程的阻塞与释放机制，当所有任务完成后，会解除阻塞并继续执行后续代码。

       总结

       sync WaitGroup是Go并发编程中不可或缺的工具，它通过Add(), Done(), 和 Wait()函数协同管理协程，确保并发任务的正确执行顺序。掌握其用法和原理，有助于在实际项目中更高效地管理并发任务。

基于 Golang 实现的 Shadowsocks 源码解析

       本教程旨在解析基于Golang实现的Shadowsocks源码，帮助大家理解如何通过Golang实现一个隧道代理转发工具。首先，让我们从代理和隧道的概念入手。

       代理（Proxy）是一种网络服务，允许客户端通过它与服务器进行非直接连接。代理服务器在客户端与服务器之间充当中转站，可以提供隐私保护或安全防护。隧道（Tunnel）则是一种网络通讯协议，允许在不兼容网络之间传输数据或在不安全网络上创建安全路径。

       实验环境要求搭建从本地到远程服务器的隧道代理，实现客户端访问远程内容。基本开发环境需包括目标网络架构。实验目的为搭建隧道代理，使客户端能够访问到指定远程服务器的内容。

       Shadowsocks通过TCP隧道代理实现，涉及客户端和服务端关键代码分析。

       客户端处理数据流时，监听本地代理地址，接收数据流并根据配置文件获取目的端IP，将此IP写入数据流中供服务端识别。

       服务端接收请求，向目的地址发送流量。目的端IP通过特定函数解析，实现数据流的接收与识别。

       数据流转发利用io.Copy()函数实现，阻塞式读取源流数据并复制至目标流。此过程可能引入阻塞问题，通过使用协程解决。

       解析源码可学习到以下技术点：

       1. 目的端IP写入数据流机制。

       2. Golang中io.Copy()函数实现数据流转发。

       3. 使用协程避免阻塞式函数影响程序运行效率。

       4. sync.WaitGroup优化并行任务执行。

       希望本文能为你的学习之旅提供指导，欢迎关注公众号获取更多技术分析内容。

Go并发编程：goroutine，channel和sync详解

       ä¼˜é›…的并发编程范式，完善的并发支持，出色的并发性能是Go语言区别于其他语言的一大特色。

       åœ¨å½“今这个多核时代，并发编程的意义不言而喻。使用Go开发并发程序，操作起来非常简单，语言级别提供关键字go用于启动协程，并且在同一台机器上可以启动成千上万个协程。

       ä¸‹é¢å°±æ¥è¯¦ç»†ä»‹ç»ã€‚

goroutine

       Go语言的并发执行体称为goroutine，使用关键词go来启动一个goroutine。

       go关键词后面必须跟一个函数，可以是有名函数，也可以是无名函数，函数的返回值会被忽略。

       go的执行是非阻塞的。

       å…ˆæ¥çœ‹ä¸€ä¸ªä¾‹å­ï¼š

packagemainimport("fmt""time")funcmain(){ gospinner(*time.Millisecond)constn=fibN:=fib(n)fmt.Printf("\rFibonacci(%d)=%d\n",n,fibN)//Fibonacci()=}funcspinner(delaytime.Duration){ for{ for_,r:=range`-\|/`{ fmt.Printf("\r%c",r)time.Sleep(delay)}}}funcfib(xint)int{ ifx<2{ returnx}returnfib(x-1)+fib(x-2)}

       ä»Žæ‰§è¡Œç»“果来看，成功计算出了斐波那契数列的值，说明程序在spinner处并没有阻塞，而且spinner函数还一直在屏幕上打印提示字符，说明程序正在执行。

       å½“计算完斐波那契数列的值，main函数打印结果并退出，spinner也跟着退出。

       å†æ¥çœ‹ä¸€ä¸ªä¾‹å­ï¼Œå¾ªçŽ¯æ‰§è¡Œæ¬¡ï¼Œæ‰“印两个数的和：

packagemainimport"fmt"funcAdd(x,yint){ z:=x+yfmt.Println(z)}funcmain(){ fori:=0;i<;i++{ goAdd(i,i)}}

       æœ‰é—®é¢˜äº†ï¼Œå±å¹•ä¸Šä»€ä¹ˆéƒ½æ²¡æœ‰ï¼Œä¸ºä»€ä¹ˆå‘¢ï¼Ÿ

       è¿™å°±è¦çœ‹Go程序的执行机制了。当一个程序启动时，只有一个goroutine来调用main函数，称为主goroutine。新的goroutine通过go关键词创建，然后并发执行。当main函数返回时，不会等待其他goroutine执行完，而是直接暴力结束所有goroutine。

       é‚£æœ‰æ²¡æœ‰åŠžæ³•è§£å†³å‘¢ï¼Ÿå½“然是有的，请往下看。

channel

       ä¸€èˆ¬å†™å¤šè¿›ç¨‹ç¨‹åºæ—¶ï¼Œéƒ½ä¼šé‡åˆ°ä¸€ä¸ªé—®é¢˜ï¼šè¿›ç¨‹é—´é€šä¿¡ã€‚常见的通信方式有信号，共享内存等。goroutine之间的通信机制是通道channel。

       ä½¿ç”¨make创建通道：

ch:=make(chanint)//ch的类型是chanint

       é€šé“支持三个主要操作：send，receive和close。

ch<-x//发送x=<-ch//接收<-ch//接收，丢弃结果close(ch)//关闭无缓冲channel

       make函数接受两个参数，第二个参数是可选参数，表示通道容量。不传或者传0表示创建了一个无缓冲通道。

       æ— ç¼“冲通道上的发送操作将会阻塞，直到另一个goroutine在对应的通道上执行接收操作。相反，如果接收先执行，那么接收goroutine将会阻塞，直到另一个goroutine在对应通道上执行发送。

       æ‰€ä»¥ï¼Œæ— ç¼“冲通道是一种同步通道。

       ä¸‹é¢æˆ‘们使用无缓冲通道把上面例子中出现的问题解决一下。

packagemainimport"fmt"funcAdd(x,yint,chchanint){ z:=x+ych<-z}funcmain(){ ch:=make(chanint)fori:=0;i<;i++{ goAdd(i,i,ch)}fori:=0;i<;i++{ fmt.Println(<-ch)}}

       å¯ä»¥æ­£å¸¸è¾“出结果。

       ä¸»goroutine会阻塞，直到读取到通道中的值，程序继续执行，最后退出。

缓冲channel

       åˆ›å»ºä¸€ä¸ªå®¹é‡æ˜¯5的缓冲通道：

ch:=make(chanint,5)

       ç¼“冲通道的发送操作在通道尾部插入一个元素，接收操作从通道的头部移除一个元素。如果通道满了，发送会阻塞，直到另一个goroutine执行接收。相反，如果通道是空的，接收会阻塞，直到另一个goroutine执行发送。

       æœ‰æ²¡æœ‰æ„Ÿè§‰ï¼Œå…¶å®žç¼“冲通道和队列一样，把操作都解耦了。

单向channel

       ç±»åž‹chan<-int是一个只能发送的通道，类型<-chanint是一个只能接收的通道。

       ä»»ä½•åŒå‘通道都可以用作单向通道，但反过来不行。

       è¿˜æœ‰ä¸€ç‚¹éœ€è¦æ³¨æ„ï¼Œclose只能用在发送通道上，如果用在接收通道会报错。

       çœ‹ä¸€ä¸ªå•å‘通道的例子：

packagemainimport"fmt"funccounter(outchan<-int){ forx:=0;x<;x++{ out<-x}close(out)}funcsquarer(outchan<-int,in<-chanint){ forv:=rangein{ out<-v*v}close(out)}funcprinter(in<-chanint){ forv:=rangein{ fmt.Println(v)}}funcmain(){ n:=make(chanint)s:=make(chanint)gocounter(n)gosquarer(s,n)printer(s)}sync

       sync包提供了两种锁类型：sync.Mutex和sync.RWMutex，前者是互斥锁，后者是读写锁。

       å½“一个goroutine获取了Mutex后，其他goroutine不管读写，只能等待，直到锁被释放。

packagemainimport("fmt""sync""time")funcmain(){ varmutexsync.Mutexwg:=sync.WaitGroup{ }//主goroutine先获取锁fmt.Println("Locking(G0)")mutex.Lock()fmt.Println("locked(G0)")wg.Add(3)fori:=1;i<4;i++{ gofunc(iint){ //由于主goroutine先获取锁，程序开始5秒会阻塞在这里fmt.Printf("Locking(G%d)\n",i)mutex.Lock()fmt.Printf("locked(G%d)\n",i)time.Sleep(time.Second*2)mutex.Unlock()fmt.Printf("unlocked(G%d)\n",i)wg.Done()}(i)}//主goroutine5秒后释放锁time.Sleep(time.Second*5)fmt.Println("readyunlock(G0)")mutex.Unlock()fmt.Println("unlocked(G0)")wg.Wait()}

       RWMutex属于经典的单写多读模型，当读锁被占用时，会阻止写，但不阻止读。而写锁会阻止写和读。

packagemainimport("fmt""sync""time")funcmain(){ varrwMutexsync.RWMutexwg:=sync.WaitGroup{ }Data:=0wg.Add()fori:=0;i<;i++{ gofunc(tint){ //第一次运行后，写解锁。//循环到第二次时，读锁定后，goroutine没有阻塞，同时读成功。fmt.Println("Locking")rwMutex.RLock()deferrwMutex.RUnlock()fmt.Printf("Readdata:%v\n",Data)wg.Done()time.Sleep(2*time.Second)}(i)gofunc(tint){ //写锁定下是需要解锁后才能写的rwMutex.Lock()deferrwMutex.Unlock()Data+=tfmt.Printf("WriteData:%v%d\n",Data,t)wg.Done()time.Sleep(2*time.Second)}(i)}wg.Wait()}总结

       å¹¶å‘编程算是Go的特色，也是核心功能之一了，涉及的知识点其实是非常多的，本文也只是起到一个抛砖引玉的作用而已。

       æœ¬æ–‡å¼€å§‹ä»‹ç»äº†goroutine的简单用法，然后引出了通道的概念。

       é€šé“有三种：

       æ— ç¼“冲通道

       ç¼“冲通道

       å•å‘通道

       æœ€åŽä»‹ç»äº†Go中的锁机制，分别是sync包提供的sync.Mutex（互斥锁）和sync.RWMutex（读写锁）。

       goroutine博大精深，后面的坑还是要慢慢踩的。

       æ–‡ç« ä¸­çš„脑图和源码都上传到了GitHub，有需要的同学可自行下载。

       åœ°å€ï¼šgithub.com/yongxinz/gopher/tree/main/sc

       ä½œè€…：yongxinz