想必现在很多人对于并发更新map会出现的问题方面的知识都特别想要了解，那么老赵就为大家整理了一些关于go map并发问题方面的知识分享给大家，希望可以帮助到你。
在过去，Web开发的工作很少涉及并发的问题。每个用户的请求都是在一个独立的线程中发出的，偶尔会涉及到异步任务。但是线程间的数据同步模型非常简单，所以并发性还没有被深入挖掘。最近在写游戏相关的服务器端代码时，发现有很多数据并发同步的场景，于是花了一点时间去探索。这是系列文章的第三篇。
本文简要介绍了图型在戈朗的安全使用。
在业务逻辑中保存key-value是一个很常见的需求，所以Map的使用场景很多。
在Golang源代码实现中，对地图的要求很高(见《Go maps in action》):地图并发使用不安全3360没有定义当你同时读写它们时会发生什么。(并发使用时Maps不安全，并发读写地图时无法预测会发生什么)。
如果在没有保护的情况下，在不同的线程中读写map类型的数据，代码将直接崩溃并异常退出。例如，下面的代码：
运行上面的代码可以得到以下类似的结果：
从输出结果来看，Golang runtime明确禁止并发读写map，检测到这种情况后直接异常退出。这不同于其他数据类型，如int、string等。对比以下代码(注意：以下代码存在隐藏的并发问题。详见Golang中数据的并发同步(第二部分):
还是那句话，虽然上面的代码在不同线程访问int数据时不会直接退出，但是这种没有任何安全措施的并发读写是有安全隐患的。详情请参考。
浅谈Golang中数据的并发与同步(2)。
由于Golang不允许在运行时并发读写map，所以当需要在多线程中读写map时，显而易见的办法就是锁定它(如Golang中数据并发同步第一部分所述)。
下面的代码将map类型的m封装在一个匿名结构中，整个匿名结构继承了sync的结构。RWMutex，所以它具有添加读写锁的功能，从而安全地实现了多线程的“并发读写”来映射：
最后，我来问这个问题：为什么在多线程读写时，int、string、slice等变量运行正常，而在多线程并发读写时，map异常退出？其实这涉及到map的具体实现(我知道这是一句废话_)。
简单来说，我们可以从Go源代码中map runtime的相关部分窥见一些证据：map的增加、修改、删除可以分别对应func mapassign()、func mapaccess1()和func mapdelete()函数，每个函数都有很长的执行逻辑；如果多个线程并发读写同一个map，有很大概率 mapaccess1在执行MapAssign函数的中途读取对应的零值(增加一个key的值)， mapdelete在执行mapaccess1函数的中途删除对应的key(读取一个key的值)，以此类推。
同时，考虑到添加或删除数据时底层数据的变化(比如扩充和重分布，可以参考深度好文|面试大厂围棋岗位时会问到的地图知识点)，保持地图简单很重要；为了避免难以调试的异常，运行时环境显式并发异常存在是可以理解的。
Golang运行时会在添加、修改、删除地图的过程中检测是否存在并发读写，当发现并发读写时会直接异常退出。与其他数据类型(如int、string、slice等)相比。)，map的并发使用更严格(安全性能的妥协)；可以认为map的严格性大大减少了怪异bug的产生，增加了代码的健壮性。
最后提到map的并发使用，sync的使用。经常提到Map，但是由于大量使用了接口{}类型，使用起来并不是那么方便；到目前为止，我更喜欢通过添加读写锁来使用map，而不是使用线程安全同步。地图
原： https://jingwei.link/2019/05/12/golang-concurrency-03-map.html
相关问答：请问Golang是怎么具体实现高并发的？
一、并发的意义
并发的意义就是让一个程序同时做多件事情，其目的只是为了能让程序同时做另一件事情而已，而不是为了让程序运行的更快(如果是多核处理器，而且任务可以分成相互独立的部分，那么并发确实可以让事情解决的更快)。
golang从语言级别上对并发提供了支持，而且在启动并发的方式上直接添加了语言级的关键字，不必非要按照固定的格式来定义线程函数，也不必因为启动线程的时候只能给线程函数传递一个参数而烦恼。
二、并发的启动
go的并发启动非常简单，几乎没有什么额外的准备工作，要并发的函数和一般的函数没有什么区别，参数随意，启动的时候只需要加一个go关键之即可,其最精髓的部分在于这些协程(协程类似于线程，但是是更轻量的线程)的调度。
package main
import (
"fmt"
"time"
)
func comFunc() {
fmt.Println("This is a common function.")
}
func main() {
go comFunc()
time.Sleep(time.Second * 3)
}
三、协程间的同步与通信
1、sync.WaitGroup
sync包中的WaitGroup实现了一个类似任务队列的结构，你可以向队列中加入任务，任务完成后就把任务从队列中移除，如果队列中的任务没有全部完成，队列就会触发阻塞以阻止程序继续运行，具体用法参考如下代码：
package main
import (
"fmt"
"sync"
)
var waitGroup sync.WaitGroup
func Afunction(index int) {
fmt.Println(index)
waitGroup.Done() //任务完成，将任务队列中的任务数量-1，其实.Done就是.Add(-1)
}
func main() {
for i := 0; i < 10; i++ {
waitGroup.Add(1) //每创建一个goroutine，就把任务队列中任务的数量+1
go Afunction(i)
}
waitGroup.Wait() //.Wait()这里会发生阻塞，直到队列中所有的任务结束就会解除阻塞
}
2、channel
channel是一种golang内置的类型，英语的直译为"通道"，其实，它真的就是一根管道，而且是一个先进先出的数据结构。
我们能对channel进行的操作只有4种：
(1) 创建chennel (通过make()函数)
(2) 放入数据 (通过 channel <- data 操作)
(3) 取出数据 (通过 <-channel 操作)
(4) 关闭channel (通过close()函数)
channel的3种性质入如下：
(1) channel是一种自动阻塞的管道。如果管道满了，一个对channel放入数据的操作就会阻塞，直到有某个routine从channel中取出数据，这个放入数据的操作才会执行。相反同理，如果管道是空的，一个从channel取出数据的操作就会阻塞，直到某个routine向这个channel中放入数据，这个取出数据的操作才会执行。这是channel最重要的一个性质！！！
package main
func main() {
ch := make(chan int, 3)
ch <- 1
ch <- 1
ch <- 1
ch <- 1 //这一行操作就会发生阻塞，因为前三行的放入数据的操作已经把channel填满了
}
package main
func main() {
ch := make(chan int, 3)
<-ch //这一行会发生阻塞，因为channel才刚创建，是空的，没有东西可以取出
}
(2)channel分为有缓冲的channel和无缓冲的channel。两种channel的创建方法如下：
ch := make(chan int) t//无缓冲的channel，同等于make(chan int, 0)
ch := make(chan int, 5) //一个缓冲区大小为5的channel
无缓冲通道与有缓冲通道的主要区别为：无缓冲通道存取数据是同步的，即如果通道中无数据，则通道一直处于阻塞状态；有缓冲通道存取数据是异步的，即存取数据互不干扰，只有当通道中已满时，存数据操作，通道阻塞；当通道中为空时，取数据操作，通道阻塞。
因此，使用无缓冲的channel时，放入操作和取出操作不能在同一个routine中，而且应该是先确保有某个routine对它执行取出操作，然后才能在另一个routine中执行放入操作，否则会发生死锁现象，示例如下：
package main
import (
"fmt"
"sync"
)
var waitGroup sync.WaitGroup //使用wg等待所有routine执行完毕，并输出相应的提示信息
func AFunc(ch chan int) {
waitGroup.Add(1)
FLAG:
for {
select {
case val := <-ch:
fmt.Println(val)
break FLAG
}
}
waitGroup.Done()
fmt.Println("WaitGroup Done")
}
func main() {
ch := make(chan int) //无缓冲通道
execMode := 0 //执行模式 0：先启动并发，正常输出100 1：后启动并发，发生死锁
switch execMode {
case 0:
go AFunc(ch)
ch <- 100
case 1:
ch <- 100
go AFunc(ch)
}
waitGroup.Wait()
close(ch)
}
使用带缓冲的channel时，因为有缓冲空间，所以只要缓冲区不满，放入操作就不会阻塞，同样，只要缓冲区不空，取出操作就不会阻塞。而且，带有缓冲的channel的放入和取出操作可以用在同一个routine中。但是，一定要注意放入和取出的速率问题，否则也会发生死锁现象，示例如下：
package main
import (
"fmt"
"sync"
)
var waitGroup sync.WaitGroup
func AFunc(ch chan int, putMode int) {
val := <-ch
switch putMode {
case 0:
fmt.Printf("Vaule=%dn", val)
case 1:
fmt.Printf("Vaule=%dn", val)
for i := 1; i <= 5; i++ {
ch <- i * val
}
case 2:
fmt.Printf("Vaule=%dn", val)
for i := 1; i <= 5; i++ {
<-ch
}
}
waitGroup.Done()
fmt.Println("WaitGroup Done", val)
}
func main() {
ch := make(chan int, 10)
putMode := 0 //该模式下，能够正常输出所有数据
//putMode := 1//当放入速度远大于取数速度时，程序阻塞
//putMode := 2//当取数速度远大于放数速度时，程序阻塞
for i := 0; i < 1000; i++ {
ch <- i
waitGroup.Add(1)
go AFunc(ch, putMode)
}
waitGroup.Wait()
close(ch)
}
(3)关闭后的channel可以取数据，但是不能放数据。而且，channel在执行了close()后并没有真的关闭，channel中的数据全部取走之后才会真正关闭。
package main
func main() {
ch := make(chan int, 5)
ch <- 1
ch <- 1
close(ch)
ch <- 1 //不能对关闭的channel执行放入操作
// 会触发panic
}
package main
func main() {
ch := make(chan int, 5)
ch <- 1
ch <- 1
close(ch)
<-ch //只要channel还有数据，就可能执行取出操作
//正常结束
}
package main
import "fmt"
func main() {
ch := make(chan int, 5)
ch <- 1
ch <- 1
ch <- 1
ch <- 1
close(ch) //如果执行了close()就立即关闭channel的话，下面的循环就不会有任何输出了
for {
data, ok := <-ch
if !ok {
break
}
fmt.Println(data)
}
// 输出：
// 1
// 1
// 1
// 1
//