An interview question about concurrent reading and writing of map in golang

What's wrong with the code below ?

package main

import (
	"fmt"
	"sync"
)

//  What's wrong with the code below ?
type UserAges struct {
    
	ages map[string]int
	sync.Mutex
}

func (ua *UserAges) Add(name string, age int) {
    
	ua.Lock()
	defer ua.Unlock()
	ua.ages[name] = age
}

func (ua *UserAges) Get(name string) int {
    
	if age, ok := ua.ages[name]; ok {
    
		return age
	}
	return -1
}

// test
func main() {
    
	ua := &UserAges{
    ages: make(map[string]int, 0)}

	wg := &sync.WaitGroup{
    }
	wg.Add(10 + 4)

	// write
	for gid := 10000; gid < 10010; gid++ {
    
		go func(gid int, u *UserAges) {
    
			for i := 0; i < 100000; i++ {
    
				name := fmt.Sprintf("gid%d-%d", gid, i)
				u.Add(name, i)
			}
			wg.Done()
		}(gid, ua)
	}

	// read
	for gid := 10000; gid < 10004; gid++ {
    
		go func(gid int, u *UserAges) {
    
			for i := 0; i < 100000; i++ {
    
				name := fmt.Sprintf("gid%d-%d", gid, i)
				_ = u.Get(name)
			}
			wg.Done()
		}(gid, ua)
	}

	wg.Wait()
}

Please think about it. , The answer and analysis are in the following
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,

answer , Meeting panic

fatal error: concurrent map read and map write

Why? ？

// map It is not safe to read and write concurrently .map It's a reference type ,
//  When reading and writing concurrently, multiple processes can access the same address through pointers , That is, access to shared variables , At this time, there is a competitive relationship between reading and writing resources . Error messages will be reported :
// fatal error: concurrent map read and map write


// sync.Mutex  and  sync.RWMutex
//
// Mutex  Is mutex ,Lock()  Lock ,Unlock()  Unlock 
//
// RWMutex  Lock for read and write ,
//  Writing locks will prevent other  goroutine（ Whether reading or writing ） Come in , The whole lock consists of  goroutine  Monopoly 
//  It is suitable for reading more and writing less 

How to rewrite , To solve the problem of concurrency ？

The first 1 Kind of ： Add mutexes to reads

func (ua *UserAges) Get(name string) int {
    
	ua.Lock()
	defer ua.Unlock()
	if age, ok := ua.ages[name]; ok {
    
		return age
	}
	return -1
}

The first 2 Kind of , use sync.RWMutex rewrite , fit “ Read more and write less ” Concurrent scenarios

type UserAges struct {
    
	ages map[string]int
	sync.RWMutex
}

func (ua *UserAges) Get(name string) int {
    
	ua.Lock()
	defer ua.Unlock()
	if age, ok := ua.ages[name]; ok {
    
		return age
	}
	return -1
}