go---并发安全字典 sync.Map
自制的简易并发安全字典
package main
import (
"fmt"
"sync"
)
// 自制的简易并发安全字典
type ConcurrentMap struct {
m map[interface{}]interface{}
mu sync.RWMutex
}
func NewConcurrentMap() *ConcurrentMap {
return &ConcurrentMap {
m: make(map[interface{}]interface{}),
}
}
func (cMap *ConcurrentMap) Delete (key interface{}) {
cMap.mu.Lock()
defer cMap.mu.Unlock()
delete(cMap.m, key)
}
func (cMap *ConcurrentMap) Load(key interface{}) (value interface{}, ok bool) {
cMap.mu.RLock()
defer cMap.mu.RUnlock()
value, ok = cMap.m[key]
return
}
func (cMap *ConcurrentMap) LoadOrStore(key, value interface{}) (actual interface{}, loaded bool) {
cMap.mu.Lock()
defer cMap.mu.Unlock()
actual, loaded = cMap.m[key]
if loaded {
return
}
cMap.m[key] = value
actual = value
return
}
func (cMap *ConcurrentMap) Range(f func(key, value interface{}) bool) {
cMap.mu.RLock()
defer cMap.mu.RUnlock()
for k, v := range cMap.m {
if !f(k, v) {
break
}
}
}
func (cMap *ConcurrentMap) Store(key, value interface{}) {
cMap.mu.Lock()
defer cMap.mu.Unlock()
cMap.m[key] = value
}
func main() {
pairs := []struct {
k int
v string
} {
{k: 1, v: "a"},
{k: 2, v: "b"},
{k: 3, v: "c"},
{k: 4, v: "d"},
}
cMap := NewConcurrentMap()
cMap.Store(pairs[0].k, pairs[0].v)
cMap.Store(pairs[1].k, pairs[1].v)
cMap.Store(pairs[2].k, pairs[2].v)
fmt.Println("[Three pairs have been stored in the ConcurrentMap instancel]")
cMap.Range(func(key, value interface{}) bool {
fmt.Printf("The result of an iteration in Range: %v, %v\n", key, value)
return true
})
k0 := pairs[0].k
v0, ok := cMap.Load(k0)
fmt.Printf("The result of Load: %v, %v (key: %v)\n", v0, ok, k0)
k2, v2 := pairs[2].k, pairs[2].v
actual2, loaded2 := cMap.LoadOrStore(k2,v2)
fmt.Printf("The result of LoadOrStore: %v, %v (key: %v, value: %v)\n",
actual2, loaded2, k2, v2)
k1 := pairs[1].k
cMap.Delete(k1)
fmt.Printf("[The pair with the key of %v has been removed from the ConcurrentMap instance]\n", k1)
v1, ok := cMap.Load(k1)
v1 = pairs[1].v
actual1, loaded1 := cMap.LoadOrStore(k1, v1)
fmt.Printf("The result of LoadOrStore: %v, %v (key: %v, value: %v)\n",
actual1, loaded1, k1, v1)
cMap.Range(func(key, value interface{}) bool {
fmt.Printf("The result of an iteration in Range: %v, %v\n", key, value)
return true
})
}
sync.Map
为了进一步明确并发安全字段中键值的实际类型，有两种方案：
- 在编码时就完全确定键和值的类型，然后利用 Go 语言的编译器检查。
- 接受动态的类型设置，并在程序运行时通过反射操作进行检查。
前一种方案在扩展性方面有所欠缺，后一种方案通常会影响程序的性能。
sync.Map 中的 read 与 dirty 字段：
sync.Map 中的 read 与 dirty 互换：
第一种方案：
package main
import (
"fmt"
"sync"
)
// 键类型为 int、值类型为 string 的并发安全字典
type IntStrMap struct {
m sync.Map
}
func (iMap *IntStrMap) Delete(key int) {
iMap.m.Delete(key)
}
func (iMap *IntStrMap) Load(key int) (value string, ok bool) {
v, ok := iMap.m.Load(key)
if v != nil {
value = v.(string)
}
return
}
func (iMap *IntStrMap) LoadOrStore(key int, value string) (actual string, loaded bool) {
a, loaded := iMap.m.LoadOrStore(key, value)
actual = a.(string)
return
}
func (iMap *IntStrMap) Range(f func(key int, value string) bool) {
f1 := func(key, value interface{}) bool {
return f(key.(int), value.(string))
}
iMap.m.Range(f1)
}
func (iMap *IntStrMap) Store(key int, value string) {
iMap.m.Store(key, value)
}
func main() {
pairs := []struct {
k int
v string
} {
{k: 1, v: "a"},
{k: 2, v: "b"},
{k: 3, v: "c"},
{k: 4, v: "d"},
}
var iMap IntStrMap
iMap.Store(pairs[0].k, pairs[0].v)
iMap.Store(pairs[1].k, pairs[1].v)
iMap.Store(pairs[2].k, pairs[2].v)
fmt.Println("[Three pairs have been stored in the IntStrMap instancel]")
iMap.Range(func(key int, value string) bool {
fmt.Printf("The result of an iteration in Range: %v, %v\n", key, value)
return true
})
k0 := pairs[0].k
v0, ok := iMap.Load(k0)
fmt.Printf("The result of Load: %v, %v (key: %v)\n", v0, ok, k0)
k2, v2 := pairs[2].k, pairs[2].v
actual2, loaded2 := iMap.LoadOrStore(k2,v2)
fmt.Printf("The result of LoadOrStore: %v, %v (key: %v, value: %v)\n",
actual2, loaded2, k2, v2)
k1 := pairs[1].k
iMap.Delete(k1)
fmt.Printf("[The pair with the key of %v has been removed from the IntStrMap instance]\n", k1)
v1, ok := iMap.Load(k1)
v1 = pairs[1].v
actual1, loaded1 := iMap.LoadOrStore(k1, v1)
fmt.Printf("The result of LoadOrStore: %v, %v (key: %v, value: %v)\n",
actual1, loaded1, k1, v1)
iMap.Range(func(key int, value string) bool {
fmt.Printf("The result of an iteration in Range: %v, %v\n", key, value)
return true
})
}
第二种方案：
package main
import (
"fmt"
"sync"
"errors"
"reflect"
)
// 键类型为 int、值类型为 string 的并发安全字典
type ConcurrentMap struct {
m sync.Map
keyType reflect.Type
valueType reflect.Type
}
func NewConcurrentMap(keyType, valueType reflect.Type) (*ConcurrentMap, error) {
if keyType == nil {
return nil, errors.New("nil key type")
}
if !keyType.Comparable() {
return nil, fmt.Errorf("incomparable key type: %s", keyType)
}
if valueType == nil {
return nil, errors.New("nil value type")
}
cMap := &ConcurrentMap {
keyType: keyType,
valueType: valueType,
}
return cMap, nil
}
func (cMap *ConcurrentMap) Delete(key interface{}) {
if reflect.TypeOf(key) != cMap.keyType {
return
}
cMap.m.Delete(key)
}
func (cMap *ConcurrentMap) Load(key interface{}) (value interface{}, ok bool) {
if reflect.TypeOf(key) != cMap.keyType {
return
}
return cMap.m.Load(key)
}
func (cMap *ConcurrentMap) LoadOrStore(key, value interface{}) (actual interface{}, loaded bool) {
if reflect.TypeOf(key) != cMap.keyType {
panic(fmt.Errorf("wrong key type: %v", reflect.TypeOf(key)))
}
if reflect.TypeOf(value) != cMap.valueType{
panic(fmt.Errorf("wrong value type: %v", reflect.TypeOf(value)))
}
actual, loaded = cMap.m.LoadOrStore(key, value)
return
}
func (cMap *ConcurrentMap) Range(f func(key, value interface{}) bool) {
cMap.m.Range(f)
}
func (cMap *ConcurrentMap) Store(key, value interface{}) {
if reflect.TypeOf(key) != cMap.keyType {
panic(fmt.Errorf("wrong key type: %v", reflect.TypeOf(key)))
}
if reflect.TypeOf(value) != cMap.valueType{
panic(fmt.Errorf("wrong value type: %v", reflect.TypeOf(value)))
}
cMap.m.Store(key, value)
}
func main() {
pairs := []struct {
k int
v string
} {
{k: 1, v: "a"},
{k: 2, v: "b"},
{k: 3, v: "c"},
{k: 4, v: "d"},
}
cMap, err := NewConcurrentMap(
reflect.TypeOf(pairs[0].k), reflect.TypeOf(pairs[0].v))
if err != nil {
fmt.Printf("fatal error: %s", err)
return
}
cMap.Store(pairs[0].k, pairs[0].v)
cMap.Store(pairs[1].k, pairs[1].v)
cMap.Store(pairs[2].k, pairs[2].v)
fmt.Println("[Three pairs have been stored in the ConcurrentMap instancel]")
cMap.Range(func(key, value interface{}) bool {
fmt.Printf("The result of an iteration in Range: %v, %v\n", key, value)
return true
})
k0 := pairs[0].k
v0, ok := cMap.Load(k0)
fmt.Printf("The result of Load: %v, %v (key: %v)\n", v0, ok, k0)
k2, v2 := pairs[2].k, pairs[2].v
actual2, loaded2 := cMap.LoadOrStore(k2,v2)
fmt.Printf("The result of LoadOrStore: %v, %v (key: %v, value: %v)\n",
actual2, loaded2, k2, v2)
k1 := pairs[1].k
cMap.Delete(k1)
fmt.Printf("[The pair with the key of %v has been removed from the ConcurrentMap instance]\n", k1)
v1, ok := cMap.Load(k1)
v1 = pairs[1].v
actual1, loaded1 := cMap.LoadOrStore(k1, v1)
fmt.Printf("The result of LoadOrStore: %v, %v (key: %v, value: %v)\n",
actual1, loaded1, k1, v1)
cMap.Range(func(key, value interface{}) bool {
fmt.Printf("The result of an iteration in Range: %v, %v\n", key, value)
return true
})
}
