1.Go并发编程：goroutine，channel和sync详解
2.golang 系列：atomic 原子操作
3.Golang使用sync库和原子操作实现同步
4.golang标准库-sync包使用和应用场景
5.从项目的码解一个 panic 说起：Go 中 Sync 包的分析应用
6.手摸手Go 深入理解sync.Cond

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

golang 系列：atomic 原子操作

       Go语言系列：sync/atomic原子操作详解

       在并发编程中，确保变量的码解同步修改至关重要。除了官方提供的码解mutex，sync/atomic包提供了高效且底层的码解原子操作，确保在读写期间不受其他协程干扰。码解

       atomic包利用CPU指令进行操作，码解快拿快递源码相比mutex，码解它无需记录状态，码解性能更为出色。码解mutex主要针对代码块的码解并发控制，与变量操作有侧重不同。码解包内提供了Add、码解CompareAndSwap、码解Load、码解Store和Swap等原子操作。码解

Add: 专门针对int和uint类型进行原子加法。

CompareAndSwap: 类似乐观锁，只有当原始值等于传入的old值时，才会进行修改，可能引发ABA问题。

Load: 用于在读取时防止其他协程修改，适用于配置项的完整读取。

Store: 通过unsafe.Pointer指针实现对非int/uint类型的原子修改。

Swap: 支持int、uint和指针类型的原子值交换。

       尽管mutex的易用性和灵活性更强，但对极致性能的追求者会关注原子操作。因为，细节往往决定性能。如果你对这个话题感兴趣，可以访问我们的公众号「阅新技术」，那里有更多的技术分享。

       感谢您的关注和支持，期待您的互动，一起探索更多新知识！权益卡源码

Golang使用sync库和原子操作实现同步

       每个*sync.Once值有一个Do(f func())方法，该方法接收一个类型为func()的参数。在多个协程中，此方法可以被多次并发执行，参数应为同一个函数值。其中，只有一个调用实参函数将得到调用。被调用函数在任何o.Do()方法调用返回前退出。通常用于确保并发程序中代码执行一次。

       一个例子中，Hello仅输出一次，而world!输出五次，且Hello在所有world!之前。

       *sync.Mutex和*sync.RWMutex实现sync.Locker接口，拥有Lock()和Unlock()方法，保护数据不被多个协程同时读取和修改。*sync.RWMutex添加RLock()和RUnlock()方法，支持多个读取者并发读取，防止数据同时被写入者和其他访问者使用。

       *sync.Mutex使用锁确保数据不被多个协程同时使用。在Counter示例中，Mutex字段确保了字段n不会被多个协程同时使用。

       *sync.RWMutex在内部包含写锁和读锁，RLock()和RUnlock()方法允许并发读取，Lock()和Unlock()方法用于加锁和解锁。

       使用sync.Mutex和sync.RWMutex实现通知，尽管不是最优雅的实现方式。示例中，Hi确保在Bye前打印。

       sync.Cond提供多协程通知机制，维护等待协程队列，Wait()、Signal()和Broadcast()方法用于等待、通知和广播。溯源码特级

       原子操作整数在并发环境保证无数据竞争，如并发递增int值。Add()原子操作确保个协程递增后打印。

       StoreT和LoadT原子操作适用于并发实现setter和getter方法。示例中使用原子操作。

       对于无符号整数类型T值的原子减法操作，AddT函数调用的第二个实参需为非负数。SwapT和CompareAndSwapT函数实现置换和比较交换操作。

       在Go 1.之前，位字原子操作要求内存地址为8字节对齐，但在Go 1.引入的原子方法操作上，这一要求在-bit和-bit架构上总是得到满足。然而，对于-bit架构上的原子函数操作，这一要求并非总能得到满足。详情请参阅关于Go值的内存布局。

golang标准库-sync包使用和应用场景

       大家好，我是小许，标准库中的sync包在我们的日常开发中用的颇为广泛，那么大家对sync包的用法知道多少呢，这篇文章就大致讲一下sync包和它的使用

       Package sync provides basic synchronization primitives such as mutual exclusion locks. Other than the Once and WaitGroup types, most are intended for use by low-level library routines. Higher-level synchronization is better done via channels and communication. Values containing the types defined in this package should not be copied.

       这句话大意就是说：sync包提供了基本的同步基元，如互斥锁。除了Once和WaitGroup类型，大部分都是适用于低水平程序线程，高水平的同步使用channel通信更好一些

       包中定义了以下类型: Locker, Once, Mutex, RWMutex, WaitGroup, Pool。接下来我们逐个讲每种类型的使用,所有这些在Go sdk中的src/runtime/sync包，可逐个查看，特别是结合test一起

       Locker接口，包含Lock()和Unlock()两个方法，用于代表一个能被加锁和解锁的对象.

       Lock方法锁住Mutex，如果Mutex已经加锁，则阻塞直到m解锁

       Unlock方法解锁m,如果解锁一个未加锁的mutex会导致运行时错误、锁定m与特定的groutine无关。允许不同的qfile系统源码groutine进行加锁、解锁

       1.Once是只执行一次动作的对象，使用后不得复制

       Once只有一个Do方法

       Do方法当且仅当第一次被调用时才执行函数f。once.Do(f)被多次调用，只有第一次调用会执行f，即使f每次调用Do 提供的f值不同。需要给每个要执行仅一次的函数都建立一个Once类型的实例

       Mutex是一个互斥锁，可以创建为其他结构体的字段；零值为解锁状态。Mutex类型的锁和线程无关，可以由不同的线程加锁和解锁。实现了Locker()接口的UnLock()和Locker()方法，同一时刻一段代码只能被一个线程运行

       Mutex在大量并发的情况下，会造成锁等待，对性能的影响比较大

       4.RWMutex是一个读写互斥锁，该锁可以被同时多个读取者持有或唯一个写入者持有

       有以下方法可使用

       WaitGroup 对象内部有一个计数器，最初从0开始，它有三个方法：Add(), Done(), Wait() 用来控制计数器的数量。Add(n) 把计数器设置为n ，Done() 每次把计数器-1 ，wait() 会阻塞代码的运行，直到计数器的值减为0.

       使用示例

       Pool是一个可以分别存取的临时对象的集合，可以被看作是一个存放可重用对象的值的容器、过减少GC来提升性能，是Goroutine并发安全的。有两个方法 Get()、Set()

       其实在开发使用中我们间接也是使用到了sync.Pool,比如标准库中的fmt、还有gin、iris框架中的Context

       fmt中sync.Pool

       newPrinter就是调用的sync.Pool.Get(),拿到pp指针.首先是做了一些format操作。然后调用free()方法，将使用过得pp放回到ppFree中。归还之前将p的部分字段重置，以保证下次调用的是原始pp

       iris框架中的Context中的sync.Pool

       iris.New()创建并返回一个空的 iris *Application实例。New()函数中的context.New(),传入一个func,返回一个context.Pool给到 Application的ContextPool。可以看到传入的func实际是给到了sync.Pool.New。app.ContextPool就是全民传奇源码存储上下文变量Context的管理池。

       Acquire()获取context， Release()释放对象

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

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

       sync包在Golang 1.9之后被官方支持，其中包含了丰富的同步原语，是并发编程的关键部分。在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的使用技巧和注意事项。在实际编程中，正确使用这些同步原语对于避免并发问题至关重要。

手摸手Go 深入理解sync.Cond

       sync.Cond 是一个用于等待一个或一组goroutines满足条件后唤醒的条件变量实现。它关联一个锁，通常是 *Mutex 或 RWMutex，具体根据需求初始化。

       sync.Cond的基本用法以实现FIFO队列为例。我们定义了队列的Offer和Pop操作。一个goroutine不断向队列投放数据，同时有两个goroutines不断取拿数据。Cond帮助我们管理队列的访问。

       在使用sync.Mutex时，需要理解其核心功能。具体地，Cond.wait()的使用遵循特定模板，其逻辑将在后续分析中详细说明。

       sync.Cond的数据结构包含三个部分：noCopy、Locker和copyChecker。noCopy确保实例不可复制，Locker用于互斥访问，copyChecker检查Cond实例是否被复制。当实例被复制时，会检查并确保内存地址的正确性。

       sync.Cond的notifyList包含三类字段，用于管理等待的goroutines。整体结构简单明了。

       sync.Cond的核心操作Wait()分为五个步骤，主要完成两个任务：等待和加入等待链表。Signal操作唤醒一个等待时间最长的goroutine，无需持有锁。Broadcast()与Signal()区别在于它可以唤醒全部等待的goroutine，并直接更新等待链表。

       总结sync.Cond的使用，它提供了一种高效管理goroutines等待和唤醒的机制，简化了多线程编程中的同步问题。通过源码分析，我们深入了解了Cond的内部实现，为实际应用提供了基础。

浅析Golang中互斥锁解决并发安全问题（附代码实例）

       今天我们来聊一聊锁吧，我们都知道有并发就有并发安全的问题。对于有的变量不能是并发运行访问的。比如银行的存取款业务，假如可以并发进行的话，你想一想你往银行存这个月的工资万，你老婆同一时间在银行取万去做美容。假如不使用锁，你存完之后发现金额没有变化，你老婆取完钱后发现钱也没有变化。你是慌死了，那你老婆不高兴坏了.......

       所以我们这里就需要用到锁，当一个人访问这个业务时，就给它加上锁，别人就不能访问了。

       看一看这个存钱的例子：

varwgsync.WaitGroupfuncmain(){ varmoney=fori:=0;i<;i++{ wg.Add(1)gofunc(){ forj:=0;j<;j++{ money+=1}wg.Done()}()}wg.Wait()fmt.Println("最终金额",money)}

       这个例子就是个人每个人给你存块钱。这一百块钱分一百次存。这样存完后我们就有三千块钱了。

       我们看一看运行结果：

最终金额

       好像是没问题哦！那我们加大一下存款金额吧。让个人每个人存，这一千块钱分一千次存，这样我们就会得到一万二千块钱，来看一看运行结果吧！

最终金额

       是不是和我们预想得不一样？

       这就是出现了并发安全问题。

       对于这种问题，我们应该不允许并发访问。

       然后我们看看怎么使用互斥锁解决这类问题吧！

funcmain(){ varmoney=varmtsync.Mutexwg.Add(1)gofunc(){ fmt.Println("搏达试图抢断")mt.Lock()fmt.Println("搏达抢断成功")money-=<-time.After(*time.Second)mt.Unlock()fmt.Println("搏达扔了球")wg.Done()}()wg.Add(1)gofunc(){ fmt.Println("搏达试图跳舞")mt.Lock()fmt.Println("搏达跳舞成功")money-=<-time.After(*time.Second)mt.Unlock()fmt.Println("搏达放弃跳舞")wg.Done()}()wg.Wait()}

       这段程序的意义是两个协程同时抢锁，跳舞协程先抢到锁的话，搏达就开始跳舞，然后跳完舞解锁，抢断协程开始抢到锁，然后搏达结束跳舞开始抢断。如果抢断协程先抢到锁的话，搏达就先开始抢断然后再跳舞。

       运行结果是：

搏达试图抢断搏达抢断成功搏达试图跳舞搏达扔了球搏达跳舞成功搏达放弃跳舞

       我们可以看到，搏达扔了球才能开始跳舞。这就是锁的功劳，让搏达不至于一边跳舞一边抢断而累趴。

       作者：ReganYue

Go实例讲解，并发编程-map并发读写的线程安全性问题

       先上实例代码，后面再来详细讲解。

       /** * 并发编程，map的线程安全性问题，使用互斥锁的方式 */ package main import ( "sync" "time" "fmt" ) var data map[int]int = make(map[int]int) var wgMap sync.WaitGroup = sync.WaitGroup{ } var muMap sync.Mutex = sync.Mutex{ } func main() { // 并发启动的协程数量 max := wgMap.Add(max) time1 := time.Now().UnixNano() for i := 0; i < max; i++ { go modifySafe(i) } wgMap.Wait() time2 := time.Now().UnixNano() fmt.Printf("data len=%d, time=%d", len(data), (time2-time1)/) } // 线程安全的方法，增加了互斥锁 func modifySafe(i int) { muMap.Lock() data[i] = i muMap.Unlock() wgMap.Done() }

       上面的代码中 var data map[int]int 是一个key和value都是int类型的map，启动的协程并发执行时，也只是非常简单的对 data[i]=i 这样的一个赋值操作。

       主程序发起1w个并发，不断对map中不同的key进行赋值操作。

       在不安全的情况下，我们直接就看到一个panic异常信息，程序是无法正常执行完成的，如下：

       fatal error: concurrent map writes goroutine [running]: runtime.throw(0x4d6e, 0x) C:/Go/src/runtime/panic.go: +0x9c fp=0xcbf sp=0xcbf pc=0xac runtime.mapassign_fast(0x4ba4c0, 0xce, 0xc, 0x0) C:/Go/src/runtime/hashmap_fast.go: +0x3d9 fp=0xcbfa8 sp=0xcbf pc=0xbed9 main.modifyNotSafe(0xc) mainMap.go: +0x4a fp=0xcbfd8 sp=0xcbfa8 pc=0x4a1f1a runtime.goexit() C:/Go/src/runtime/asm_amd.s: +0x1 fp=0xcbfe0 sp=0xcbfd8 pc=0xcc1 created by main.main mainMap.go: +0x

       对比之前《 Go实例讲解，并发编程-slice并发读写的线程安全性问题》，slice的数据结构在不安全的并发执行中是不会报错的，只是数据可能会出现丢失。

       而这里的map的数据结构，是直接报错，所以在使用中就必须认真对待，否则整个程序是无法继续执行的。

       所以也看出来，Go在对待线程安全性问题方面，对slice还是更加宽容的，对map则更加严格，这也是在并发编程时对我们提出了基本的要求。

       将上面的代码稍微做些修改，对 data[i]=i 的前后增加上 muMap.Lock() 和 muMap.Unlock() ，也就保证了多线程并行的情况下，遇到冲突时有互斥锁的保证，避免出现线程安全性问题。

       关于为什么会出现线程安全性问题，这里就不再详细讲解了，大家可以参考之前的两篇文章《 Go实例讲解，并发编程-slice并发读写的线程安全性问题》和《 Go实例讲解，并发编程-数字递增的线程安全性问题》。

       这里，我们再来探讨一个问题，如何保证map的线程安全性？

       上面我们是通过 muMap 这个互斥锁来保证的。

       而Go语言有一个概念：“不要通过共享内存来进行通信，而应该通过通信来共享内存”，也就是利用channel来保证线程安全性。

       那么，这又要怎么来做呢？下面是实例代码：

       /** * 并发编程，map的线程安全性问题，使用channel的方式 */ package main import ( "time" "fmt" ) var dataCh map[int]int = make(map[int]int) var chMap chan int = make(chan int) func main() { // 并发启动的协程数量 max := time1 := time.Now().UnixNano() for i := 0; i < max; i++ { go modifyByChan(i) } // 处理channel的服务 chanServ(max) time2 := time.Now().UnixNano() fmt.Printf("data len=%d, time=%d", len(dataCh), (time2-time1)/) } func modifyByChan(i int) { chMap <- i } // 专门处理chMap的服务程序 func chanServ(max int) { for { i := <- chMap dataCh[i] = i if len(dataCh) == max { return } } }

       数据填充的方式我们还是用1w个协程来做，只不过使用了chMap这个channel来做队列。

       然后在 chanServ 函数中启动一个服务，专门来消费chMap这个队列，然后把数据给map赋值 dataCh[i]=i 。

       从上面简单的对比中，我们还看不出太多的区别，我们还是可以得出下面一些

       1 通过channel的方式，其实就是通过队列把并发执行的数据读写改成了串行化，以避免线程安全性问题；

       2 多个协程交互的时候，可以通过依赖同一个 channel对象来进行数据的读写和传递，而不需要共享变量，可以参考之前的文章《 Go实例讲解，利用channel实现协程的互动-会聊天的Tom&Jerry》；

       我们再来对比一下程序的执行效率。

       使用互斥锁的方式，执行返回数据如下：

       data len=, time=4

       使用channel的方式，执行返回数据如下：

       data len=, time=

       可以看出，这种很简单的针对map并发读写的场景，通过互斥锁的方式比channel的方式要快很多，毕竟channel的方式增加了channel的读写操作，而且channel的串行化处理，效率上也会低一些。

       所以，根据具体的情况，我们可以考虑优先用什么方式来实现。

       优先使用互斥锁的场景：

       1 复杂且频繁的数据读写操作，如：缓存数据；

       2 应用中全局的共享数据，如：全局变量；

       优先使用channel的场景：

       1 协程之间局部传递共享数据，如：订阅发布模式；

       2 统一的数据处理服务，如：库存更新+订单处理；

       至此，我们已经通过3个Go实例讲解，知道在并发读写的情况下，如何搞定线程安全性问题，简单的数据结构就是int类型的安全读写，复杂的数据结构分别详细讲解了slice和map。在这次map的讲解中，还对比了互斥锁和channel的方式，希望大家能够对并发编程有更深入的理解。