keakon的涂鸦馆

fatal error: sync: unlock of unlocked mutex

goroutine 63756060 [running]:
runtime.throw({0xbeeca9, 0xb45120})
#011/usr/local/go/src/runtime/panic.go:1198 +0x71 fp=0xc0010f13a0 sp=0xc0010f1370 pc=0x4336d1
sync.throw({0xbeeca9, 0xb2dd40})
#011/usr/local/go/src/runtime/panic.go:1184 +0x1e fp=0xc0010f13c0 sp=0xc0010f13a0 pc=0x45ecfe
sync.(*Mutex).unlockSlow(0x11d45a0, 0xffffffff)
#011/usr/local/go/src/sync/mutex.go:196 +0x3c fp=0xc0010f13e8 sp=0xc0010f13c0 pc=0x47851c
sync.(*Mutex).Unlock(...)
#011/usr/local/go/src/sync/mutex.go:190
sync.(*Map).Store(0x11d45a0, {0xae4960, 0xc0012f4350}, {0xae40e0, 0xc000026078})
#011/usr/local/go/src/sync/map.go:163 +0x465 fp=0xc0010f1480 sp=0xc0010f13e8 pc=0x476fa5

var onlineCache sync.Map

func AddOnlineDevice(uuid string) {
	ts := time.Now().Unix()
	onlineCache.Store(uuid, ts)
}

func SaveOnlineTimes() {
	onlineTimes := map[interface{}]interface{}{}

	onlineCache.Range(func(key, value interface{}) bool {
		onlineTimes[key] = value
		return true
	})
	onlineCache = sync.Map{}

	if len(onlineTimes) == 0 {
		return
	}

	err := dao.Get().Redis.UpdateOnlineTimes(onlineTimes)
	if err != nil {
		log.Error(err)
	}
}

func UpdateClientOnlineTimeCron() {
	go func() {
		for {
			<-time.After(time.Second * 30)

			SaveOnlineTimes()
		}
	}()
}

package main

import (
	"math/rand"
	"sync"
	"time"
)


func main() {
	sm := sync.Map{}
	for i := 0; i < 10; i++ {
		go func() {
			for {
				a := rand.Float32()
				b := rand.Float32()
				sm.Store(a, b)
			}
		}()
	}

	for {
		sm = sync.Map{}
		time.Sleep(time.Second)
	}
}

Although technically that doesn't violate the rule "don't copy a map before first use" because the map you're copying hasn't been used yet. But you're copying onto an in-use Map, which is also bad.

func (m *Map) Store(key, value any) {
	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()
}