use go1.19 atomic.Pointer

Author: wdvxdr1123

go.mod

@@ -1,3 +1,3 @@
 module github.com/RomiChan/syncx
 
-go 1.18
+go 1.19

map.go

@@ -41,7 +41,7 @@ type Map[K comparable, V any] struct {
 	// Entries stored in read may be updated concurrently without mu, but updating
 	// a previously-expunged entry requires that the entry be copied to the dirty
 	// map and unexpunged with mu held.
-	read Pointer[readOnly[K]]
+	read atomic.Pointer[readOnly[K]]
 
 	// dirty contains the portion of the map's contents that require mu to be
 	// held. To ensure that the dirty map can be promoted to the read map quickly,
@@ -102,18 +102,25 @@ func newEntry[V any](i V) *entry {
 	return &entry{p: unsafe.Pointer(&i)}
 }
 
+func (m *Map[K, V]) loadReadOnly() readOnly[K] {
+	if p := m.read.Load(); p != nil {
+		return *p
+	}
+	return readOnly[K]{}
+}
+
 // Load returns the value stored in the map for a key, or nil if no
 // value is present.
 // The ok result indicates whether value was found in the map.
 func (m *Map[K, V]) Load(key K) (value V, ok bool) {
-	read, _ := m.read.LoadValue()
+	read := m.loadReadOnly()
 	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.LoadValue()
+		read = m.loadReadOnly()
 		e, ok = read.m[key]
 		if !ok && read.amended {
 			e, ok = m.dirty[key]
@@ -140,13 +147,13 @@ func entryLoad[V any](e *entry) (value V, ok bool) {
 
 // Store sets the value for a key.
 func (m *Map[K, V]) Store(key K, value V) {
-	read, _ := m.read.LoadValue()
+	read := m.loadReadOnly()
 	if e, ok := read.m[key]; ok && tryStore(e, &value) {
 		return
 	}
 
 	m.mu.Lock()
-	read, _ = m.read.LoadValue()
+	read = m.loadReadOnly()
 	if e, ok := read.m[key]; ok {
 		if e.unexpungeLocked() {
 			// The entry was previously expunged, which implies that there is a
@@ -204,7 +211,7 @@ func entryStoreLocked[V any](e *entry, i *V) {
 // The loaded result is true if the value was loaded, false if stored.
 func (m *Map[K, V]) LoadOrStore(key K, value V) (actual V, loaded bool) {
 	// Avoid locking if it's a clean hit.
-	read, _ := m.read.LoadValue()
+	read := m.loadReadOnly()
 	if e, ok := read.m[key]; ok {
 		actual, loaded, ok := entryTryLoadOrStore(e, value)
 		if ok {
@@ -213,7 +220,7 @@ func (m *Map[K, V]) LoadOrStore(key K, value V) (actual V, loaded bool) {
 	}
 
 	m.mu.Lock()
-	read, _ = m.read.LoadValue()
+	read = m.loadReadOnly()
 	if e, ok := read.m[key]; ok {
 		if e.unexpungeLocked() {
 			m.dirty[key] = e
@@ -272,11 +279,11 @@ func entryTryLoadOrStore[V any](e *entry, i V) (actual V, loaded, ok bool) {
 // LoadAndDelete deletes the value for a key, returning the previous value if any.
 // The loaded result reports whether the key was present.
 func (m *Map[K, V]) LoadAndDelete(key K) (value V, loaded bool) {
-	read, _ := m.read.LoadValue()
+	read := m.loadReadOnly()
 	e, ok := read.m[key]
 	if !ok && read.amended {
 		m.mu.Lock()
-		read, _ = m.read.LoadValue()
+		read = m.loadReadOnly()
 		e, ok = read.m[key]
 		if !ok && read.amended {
 			e, ok = m.dirty[key]
@@ -327,14 +334,14 @@ func (m *Map[K, V]) Range(f func(key K, value V) bool) {
 	// present at the start of the call to Range.
 	// If read.amended is false, then read.m satisfies that property without
 	// requiring us to hold m.mu for a long time.
-	read, _ := m.read.LoadValue()
+	read := m.loadReadOnly()
 	if read.amended {
 		// m.dirty contains keys not in read.m. Fortunately, Range is already O(N)
 		// (assuming the caller does not break out early), so a call to Range
 		// amortizes an entire copy of the map: we can promote the dirty copy
 		// immediately!
 		m.mu.Lock()
-		read, _ = m.read.LoadValue()
+		read = m.loadReadOnly()
 		if read.amended {
 			read = readOnly[K]{m: m.dirty}
 			m.read.Store(&read)
@@ -370,7 +377,7 @@ func (m *Map[K, V]) dirtyLocked() {
 		return
 	}
 
-	read, _ := m.read.LoadValue()
+	read := m.loadReadOnly()
 	m.dirty = make(map[K]*entry, len(read.m))
 	for k, e := range read.m {
 		if !e.tryExpungeLocked() {