Locking not preventing map to overwrite values

In this code, I am trying to enter a unique key to map, I have implemented a MySafeMap to ensure Get/Set are RW protected. Although when I execute the program, I see many of the workers end up inserted into the map. I am expecting only a unique entry to be inserted into the map and other workers to reuse it.

package main
import (
"fmt"
"log"
"sync"
"time"
)
type M struct {
c  chan string
ms *MySafeMap
}
type MySafeMap struct {
sync.RWMutex
m map[string]any
}
func (w *MySafeMap) Set(key string, value any) {
w.Lock()
defer w.Unlock()
w.m[key] = value
}
func (w *MySafeMap) Get(key string) (any, bool) {
w.RLock()
defer w.RUnlock()
v, ok := w.m[key]
return v, ok
}
func (m *M) worker(ii int) {
for {
v := <-m.c
if _, ok := m.ms.Get(v); !ok {
log.Println("entry not found, created", ii)
m.ms.Set(v, nil)
}
}
}
func main() {
m := M{
c:  make(chan string, 100),
ms: &MySafeMap{m: make(map[string]any)},
}
for ii := 0; ii < 100; ii++ {
go m.worker(ii)
}
time.Sleep(time.Second)
for ii := 0; ii < 100; ii++ {
m.c <- "10"
time.Sleep((time.Microsecond))
}
fmt.Println("Hello World")
}

and the output is

➜  Downloads go run ./prog.go
2023/03/01 20:46:36 entry not found, created 1
2023/03/01 20:46:36 entry not found, created 6
2023/03/01 20:46:36 entry not found, created 4
2023/03/01 20:46:36 entry not found, created 5
2023/03/01 20:46:36 entry not found, created 8
2023/03/01 20:46:36 entry not found, created 7
2023/03/01 20:46:36 entry not found, created 0
2023/03/01 20:46:36 entry not found, created 2
2023/03/01 20:46:36 entry not found, created 9
2023/03/01 20:46:36 entry not found, created 3
2023/03/01 20:46:36 entry not found, created 10
2023/03/01 20:46:36 entry not found, created 14
2023/03/01 20:46:36 entry not found, created 11
2023/03/01 20:46:36 entry not found, created 12
Hello World

You protected from memory race updating the map, but you still have a race condition. In general, any type of if condition then update statements are race prone. There are no guarantees that multiple goroutines will run the check, decide that the condition holds, and performs the update. You need to protect concurrent access during the whole operation:

var updateMutex sync.Mutex
func (m *M) worker(ii int) {
for {
v := <-m.c
updateMutex.Lock()
if _, ok := m.ms.Get(v); !ok {
log.Println("entry not found, created", ii)
m.ms.Set(v, nil)
}
updateMutex.Unlock()
}
}

At the begin of program,there is no v in map,and rwmutex let many gorouting get into Get() and return false ,then reset v.

• you kan use double check to prevent reset the map

func (m *M) worker(ii int) {
	for {
		v := <-m.c
		if _, ok := m.ms.Get(v); !ok {
			log.Println("entry not found,try created", ii)
			// double check
			updateMutex.Lock()
			if _, ok := m.ms.Get(v); !ok {
				print("created!\n")
				m.ms.Set(v, nil)
			}
			updateMutex.Unlock()
		}
	}
}

output:

2023/03/08 10:40:33 entry not found,try created 2
created!
2023/03/08 10:40:33 entry not found,try created 3
2023/03/08 10:40:33 entry not found,try created 4
Hello World

try many times to set,and only one set it.