Go 1.9中的sync.Map提供了线程安全的map，它的优点总结如下：（网上找的）
1.空间换时间。 通过冗余的两个数据结构(read、dirty),实现加锁对性能的影响。
2.使用只读数据(read)，避免读写冲突。
3.动态调整，miss次数多了之后，将dirty数据提升为read。
4.double-checking。
5.延迟删除。 删除一个键值只是打标记，只有在提升dirty的时候才清理删除的数据。
6.优先从read读取、更新、删除，因为对read的读取不需要锁。
其实当我们读完它内部实现后就能很好地理解以上好处了。
先从Map的数据结构看起
type Map struct {
mu Mutex
read atomic.Value // readOnly
dirty map[interface{}]*entry
misses int
}
Mutex加锁的工具，read一个只读的数据结构，所以对它的读总是线程安全的。dirty是map结构，它包含整个Map中的最新的entries，它不是线程安全的，为了保证多线程安全的情况下操作它，需要对它加锁；当dirty为空时，下一次写操作会复制read字段中未删除的数据到dirty。misses计数器，当从Map中读取entry的时候，如果read中不包含这个entry,会尝试从dirty中读取，这个时候会将misses加一， 当misses累积到 dirty的长度的时候， 就会将dirty提升为read,避免从dirty中miss太多次。因为操作dirty需要加锁。
其中read atomic.Value中存的是readOnly数据结构，我们来看下readOnly
type readOnly struct {
m map[interface{}]*entry
amended bool // true if the dirty map contains some key not in m.
}
m无非存数据，amended为true的话说明，dirty数组包含一些新的entries，却存没有在readOnly中。
因为这里数据是只读的，所以读数据时候优先读read数据，若read中没有，则去dirty中读，读到则misses加一。
Map中还一个expunged指针，指向被删除的键值对。Map中的entry结构体无非存有指向value的指针
var expunged = unsafe.Pointer(new(interface{}))
// An entry is a slot in the map corresponding to a particular key.
type entry struct {
p unsafe.Pointer // *interface{}
}
既然是Map，那我们先看下如何存数据，Store(key, value interfaces{})
func (m *Map) Store(key, value interface{}) {
read, _ := m.read.Load().(readOnly)
if e, ok := read.m[key]; ok && e.tryStore(&value) {
return
}
m.mu.Lock()
read, _ = m.read.Load().(readOnly)
if e, ok := read.m[key]; ok {
if e.unexpungeLocked() {
// The entry was previously expunged, which implies that there is a
// non-nil dirty map and this entry is not in it.
m.dirty[key] = e
}
e.storeLocked(&value)
} else if e, ok := m.dirty[key]; ok {
e.storeLocked(&value)
} else {
if !read.amended {
// We're adding the first new key to the dirty map.
// Make sure it is allocated and mark the read-only map as incomplete.
m.dirtyLocked()
m.read.Store(readOnly{m: read.m, amended: true})
}
m.dirty[key] = newEntry(value)
}
m.mu.Unlock()
}
先看这个情况：第一次new() Map后，里面肯定没有任何数据，第一次Store传入键值对到Map中。
首先通过atomic.Value的Load方法，加载readOnly到read中，此时read中肯定没有任何数据，于是我们要从dirty中取数据，由于它不是线程安全，所以调用mutex锁工具lock，于是读dirty中，也找不到，则判断下amended是否为false（确保是不是第一次往dirty中加数据），由于readOnly是刚创建的其ammended值为false，所以此时方法调用进入m.dirtyLocked()
func (m *Map) dirtyLocked() {
if m.dirty != nil {
return
}
read, _ := m.read.Load().(readOnly)
m.dirty = make(map[interface{}]*entry, len(read.m))
for k, e := range read.m {
if !e.tryExpungeLocked() {
m.dirty[k] = e
}
}
}
该方法创建dirty，把readOnly的（未被删除的）键值对复制到dirty中，此时readOnly为空。
func (e *entry) tryExpungeLocked() (isExpunged bool) {
p := atomic.LoadPointer(&e.p)
for p == nil {
if atomic.CompareAndSwapPointer(&e.p, nil, expunged) {
return true
}
p = atomic.LoadPointer(&e.p)
}
return p == expunged
}
创建完dirty后，会创建新的readOnly赋值给read，此时amended为true；最后在dirty中添加键值对，解锁。
情况二：如果此时并不是第一次，并且一开始就在readOnly中找到。
此时调用e.tryStore(&Value);
func (e *entry) tryStore(i *interface{}) bool {
p := atomic.LoadPointer(&e.p)
if p == expunged {
return false
}
for {
if atomic.CompareAndSwapPointer(&e.p, p, unsafe.Pointer(i)) {
return true
}
p = atomic.LoadPointer(&e.p)
if p == expunged {
return false
}
}
}
先判断取到的value是不是已经被删除的，如果是则return false；否则，调用cas替换原value的地址值指向新的value，则完成对read中的键值对的更新。如果在更新的过程中，value值被删除则return false；
情况三：如果在read中没找到，在dirty中找到，则加锁，加锁后还是要再load read（以防此时dirty晋升为read）,从read中读到被标记删除的value则cas更新dirty中对应key的value设为nil，最后调用storePionter更改value的值。
func (e *entry) storeLocked(i *interface{}) {
atomic.StorePointer(&e.p, unsafe.Pointer(i))
}
我们再来看Load()方法吧，读数据。
func (m *Map) Load(key interface{}) (value interface{}, ok bool) {
read, _ := m.read.Load().(readOnly)
e, ok := read.m[key]
if !ok && read.amended {
m.mu.Lock()
// Avoid reporting a spurious miss if m.dirty got promoted while we were
// blocked on m.mu. (If further loads of the same key will not miss, it's
// not worth copying the dirty map for this key.)
read, _ = m.read.Load().(readOnly)
e, ok = read.m[key]
if !ok && read.amended {
e, ok = m.dirty[key]
// Regardless of whether the entry was present, record a miss: this key
// will take the slow path until the dirty map is promoted to the read
// map.
m.missLocked()
}
m.mu.Unlock()
}
if !ok {
return nil, false
}
return e.load()
}老样子，先从read中找，如果找到则返回value对应的数据。如果没找到，需要判断
amended是否为true，false的话说明dirty中没有多余数据，那找不到。如果为true，则去dirty中找，操作dirty需要先加锁，先判断read中有无（防止dirty晋升成read），找到返回，没找到再找dirty，如果找到那么给misses加一。
func (m *Map) missLocked() {
m.misses++
if m.misses < len(m.dirty) {
return
}
m.read.Store(readOnly{m: m.dirty})
m.dirty = nil
m.misses = 0
}如果misses长度大于等于dirty的长度，则晋升dirty为read，这步骤复杂度为O1，因为无非指针替换，再把dirty更新为nil，misses更新为0；