复制项目

pkg/localcache/cache.go

@@ -0,0 +1,131 @@
+// Copyright © 2024 OpenIM. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package localcache
+
+import (
+	"context"
+	"hash/fnv"
+	"unsafe"
+
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/localcache/link"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/localcache/lru"
+)
+
+type Cache[V any] interface {
+	Get(ctx context.Context, key string, fetch func(ctx context.Context) (V, error)) (V, error)
+	GetLink(ctx context.Context, key string, fetch func(ctx context.Context) (V, error), link ...string) (V, error)
+	Del(ctx context.Context, key ...string)
+	DelLocal(ctx context.Context, key ...string)
+	Stop()
+}
+
+func LRUStringHash(key string) uint64 {
+	h := fnv.New64a()
+	h.Write(*(*[]byte)(unsafe.Pointer(&key)))
+	return h.Sum64()
+}
+
+func New[V any](opts ...Option) Cache[V] {
+	opt := defaultOption()
+	for _, o := range opts {
+		o(opt)
+	}
+
+	c := cache[V]{opt: opt}
+	if opt.localSlotNum > 0 && opt.localSlotSize > 0 {
+		createSimpleLRU := func() lru.LRU[string, V] {
+			if opt.expirationEvict {
+				return lru.NewExpirationLRU(opt.localSlotSize, opt.localSuccessTTL, opt.localFailedTTL, opt.target, c.onEvict)
+			} else {
+				return lru.NewLazyLRU(opt.localSlotSize, opt.localSuccessTTL, opt.localFailedTTL, opt.target, c.onEvict)
+			}
+		}
+		if opt.localSlotNum == 1 {
+			c.local = createSimpleLRU()
+		} else {
+			c.local = lru.NewSlotLRU(opt.localSlotNum, LRUStringHash, createSimpleLRU)
+		}
+		if opt.linkSlotNum > 0 {
+			c.link = link.New(opt.linkSlotNum)
+		}
+	}
+	return &c
+}
+
+type cache[V any] struct {
+	opt   *option
+	link  link.Link
+	local lru.LRU[string, V]
+}
+
+func (c *cache[V]) onEvict(key string, value V) {
+	_ = value
+
+	if c.link != nil {
+		lks := c.link.Del(key)
+		for k := range lks {
+			if key != k { // prevent deadlock
+				c.local.Del(k)
+			}
+		}
+	}
+}
+
+func (c *cache[V]) del(key ...string) {
+	if c.local == nil {
+		return
+	}
+	for _, k := range key {
+		c.local.Del(k)
+		if c.link != nil {
+			lks := c.link.Del(k)
+			for k := range lks {
+				c.local.Del(k)
+			}
+		}
+	}
+}
+
+func (c *cache[V]) Get(ctx context.Context, key string, fetch func(ctx context.Context) (V, error)) (V, error) {
+	return c.GetLink(ctx, key, fetch)
+}
+
+func (c *cache[V]) GetLink(ctx context.Context, key string, fetch func(ctx context.Context) (V, error), link ...string) (V, error) {
+	if c.local != nil {
+		return c.local.Get(key, func() (V, error) {
+			if len(link) > 0 {
+				c.link.Link(key, link...)
+			}
+			return fetch(ctx)
+		})
+	} else {
+		return fetch(ctx)
+	}
+}
+
+func (c *cache[V]) Del(ctx context.Context, key ...string) {
+	for _, fn := range c.opt.delFn {
+		fn(ctx, key...)
+	}
+	c.del(key...)
+}
+
+func (c *cache[V]) DelLocal(ctx context.Context, key ...string) {
+	c.del(key...)
+}
+
+func (c *cache[V]) Stop() {
+	c.local.Stop()
+}

pkg/localcache/cache_test.go

@@ -0,0 +1,93 @@
+// Copyright © 2024 OpenIM. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package localcache
+
+import (
+	"context"
+	"fmt"
+	"math/rand"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+)
+
+func TestName(t *testing.T) {
+	c := New[string](WithExpirationEvict())
+	//c := New[string]()
+	ctx := context.Background()
+
+	const (
+		num  = 10000
+		tNum = 10000
+		kNum = 100000
+		pNum = 100
+	)
+
+	getKey := func(v uint64) string {
+		return fmt.Sprintf("key_%d", v%kNum)
+	}
+
+	start := time.Now()
+	t.Log("start", start)
+
+	var (
+		get atomic.Int64
+		del atomic.Int64
+	)
+
+	incrGet := func() {
+		if v := get.Add(1); v%pNum == 0 {
+			//t.Log("#get count", v/pNum)
+		}
+	}
+	incrDel := func() {
+		if v := del.Add(1); v%pNum == 0 {
+			//t.Log("@del count", v/pNum)
+		}
+	}
+
+	var wg sync.WaitGroup
+
+	for i := 0; i < tNum; i++ {
+		wg.Add(2)
+		go func() {
+			defer wg.Done()
+			for i := 0; i < num; i++ {
+				c.Get(ctx, getKey(rand.Uint64()), func(ctx context.Context) (string, error) {
+					return fmt.Sprintf("index_%d", i), nil
+				})
+				incrGet()
+			}
+		}()
+
+		go func() {
+			defer wg.Done()
+			time.Sleep(time.Second / 10)
+			for i := 0; i < num; i++ {
+				c.Del(ctx, getKey(rand.Uint64()))
+				incrDel()
+			}
+		}()
+	}
+
+	wg.Wait()
+	end := time.Now()
+	t.Log("end", end)
+	t.Log("time", end.Sub(start))
+	t.Log("get", get.Load())
+	t.Log("del", del.Load())
+	// 137.35s
+}

pkg/localcache/doc.go

@@ -0,0 +1,15 @@
+// Copyright © 2024 OpenIM. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package localcache // import "git.imall.cloud/openim/open-im-server-deploy/pkg/localcache"

pkg/localcache/init.go

@@ -0,0 +1,88 @@
+// Copyright © 2024 OpenIM. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package localcache
+
+import (
+	"strings"
+	"sync"
+
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/storage/cache/cachekey"
+)
+
+var (
+	once      sync.Once
+	subscribe map[string][]string
+)
+
+func InitLocalCache(localCache *config.LocalCache) {
+	once.Do(func() {
+		list := []struct {
+			Local config.CacheConfig
+			Keys  []string
+		}{
+			{
+				Local: localCache.Auth,
+				Keys:  []string{cachekey.UidPidToken},
+			},
+			{
+				Local: localCache.User,
+				Keys:  []string{cachekey.UserInfoKey, cachekey.UserGlobalRecvMsgOptKey},
+			},
+			{
+				Local: localCache.Group,
+				Keys:  []string{cachekey.GroupMemberIDsKey, cachekey.GroupInfoKey, cachekey.GroupMemberInfoKey},
+			},
+			{
+				Local: localCache.Friend,
+				Keys:  []string{cachekey.FriendIDsKey, cachekey.BlackIDsKey},
+			},
+			{
+				Local: localCache.Conversation,
+				Keys:  []string{cachekey.ConversationKey, cachekey.ConversationIDsKey, cachekey.ConversationNotReceiveMessageUserIDsKey},
+			},
+		}
+		subscribe = make(map[string][]string)
+		for _, v := range list {
+			if v.Local.Enable() {
+				subscribe[v.Local.Topic] = v.Keys
+			}
+		}
+	})
+}
+
+func GetPublishKeysByTopic(topics []string, keys []string) map[string][]string {
+	keysByTopic := make(map[string][]string)
+	for _, topic := range topics {
+		keysByTopic[topic] = []string{}
+	}
+
+	for _, key := range keys {
+		for _, topic := range topics {
+			prefixes, ok := subscribe[topic]
+			if !ok {
+				continue
+			}
+			for _, prefix := range prefixes {
+				if strings.HasPrefix(key, prefix) {
+					keysByTopic[topic] = append(keysByTopic[topic], key)
+					break
+				}
+			}
+		}
+	}
+
+	return keysByTopic
+}

pkg/localcache/link/doc.go

@@ -0,0 +1,15 @@
+// Copyright © 2024 OpenIM. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package link // import "git.imall.cloud/openim/open-im-server-deploy/pkg/localcache/link"

pkg/localcache/link/link.go

@@ -0,0 +1,123 @@
+// Copyright © 2024 OpenIM. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package link
+
+import (
+	"hash/fnv"
+	"sync"
+	"unsafe"
+)
+
+type Link interface {
+	Link(key string, link ...string)
+	Del(key string) map[string]struct{}
+}
+
+func newLinkKey() *linkKey {
+	return &linkKey{
+		data: make(map[string]map[string]struct{}),
+	}
+}
+
+type linkKey struct {
+	lock sync.Mutex
+	data map[string]map[string]struct{}
+}
+
+func (x *linkKey) link(key string, link ...string) {
+	x.lock.Lock()
+	defer x.lock.Unlock()
+	v, ok := x.data[key]
+	if !ok {
+		v = make(map[string]struct{})
+		x.data[key] = v
+	}
+	for _, k := range link {
+		v[k] = struct{}{}
+	}
+}
+
+func (x *linkKey) del(key string) map[string]struct{} {
+	x.lock.Lock()
+	defer x.lock.Unlock()
+	ks, ok := x.data[key]
+	if !ok {
+		return nil
+	}
+	delete(x.data, key)
+	return ks
+}
+
+func New(n int) Link {
+	if n <= 0 {
+		panic("must be greater than 0")
+	}
+	slots := make([]*linkKey, n)
+	for i := 0; i < len(slots); i++ {
+		slots[i] = newLinkKey()
+	}
+	return &slot{
+		n:     uint64(n),
+		slots: slots,
+	}
+}
+
+type slot struct {
+	n     uint64
+	slots []*linkKey
+}
+
+func (x *slot) index(s string) uint64 {
+	h := fnv.New64a()
+	_, _ = h.Write(*(*[]byte)(unsafe.Pointer(&s)))
+	return h.Sum64() % x.n
+}
+
+func (x *slot) Link(key string, link ...string) {
+	if len(link) == 0 {
+		return
+	}
+	mk := key
+	lks := make([]string, len(link))
+	for i, k := range link {
+		lks[i] = k
+	}
+	x.slots[x.index(mk)].link(mk, lks...)
+	for _, lk := range lks {
+		x.slots[x.index(lk)].link(lk, mk)
+	}
+}
+
+func (x *slot) Del(key string) map[string]struct{} {
+	return x.delKey(key)
+}
+
+func (x *slot) delKey(k string) map[string]struct{} {
+	del := make(map[string]struct{})
+	stack := []string{k}
+	for len(stack) > 0 {
+		curr := stack[len(stack)-1]
+		stack = stack[:len(stack)-1]
+		if _, ok := del[curr]; ok {
+			continue
+		}
+		del[curr] = struct{}{}
+		childKeys := x.slots[x.index(curr)].del(curr)
+		for ck := range childKeys {
+			stack = append(stack, ck)
+		}
+	}
+	return del
+}

pkg/localcache/link/link_test.go

@@ -0,0 +1,34 @@
+// Copyright © 2024 OpenIM. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package link
+
+import (
+	"testing"
+)
+
+func TestName(t *testing.T) {
+
+	v := New(1)
+
+	//v.Link("a:1", "b:1", "c:1", "d:1")
+	v.Link("a:1", "b:1", "c:1")
+	v.Link("z:1", "b:1")
+
+	//v.DelKey("a:1")
+	v.Del("z:1")
+
+	t.Log(v)
+
+}

pkg/localcache/lru/doc.go

@@ -0,0 +1,15 @@
+// Copyright © 2024 OpenIM. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package lru // import "git.imall.cloud/openim/open-im-server-deploy/pkg/localcache/lru"

pkg/localcache/lru/lru.go

@@ -0,0 +1,37 @@
+// Copyright © 2024 OpenIM. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package lru
+
+import "github.com/hashicorp/golang-lru/v2/simplelru"
+
+type EvictCallback[K comparable, V any] simplelru.EvictCallback[K, V]
+
+type LRU[K comparable, V any] interface {
+	Get(key K, fetch func() (V, error)) (V, error)
+	Set(key K, value V)
+	SetHas(key K, value V) bool
+	GetBatch(keys []K, fetch func(keys []K) (map[K]V, error)) (map[K]V, error)
+	Del(key K) bool
+	Stop()
+}
+
+type Target interface {
+	IncrGetHit()
+	IncrGetSuccess()
+	IncrGetFailed()
+
+	IncrDelHit()
+	IncrDelNotFound()
+}

pkg/localcache/lru/lru_expiration.go

@@ -0,0 +1,114 @@
+// Copyright © 2024 OpenIM. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package lru
+
+import (
+	"sync"
+	"time"
+
+	"github.com/hashicorp/golang-lru/v2/expirable"
+)
+
+func NewExpirationLRU[K comparable, V any](size int, successTTL, failedTTL time.Duration, target Target, onEvict EvictCallback[K, V]) LRU[K, V] {
+	var cb expirable.EvictCallback[K, *expirationLruItem[V]]
+	if onEvict != nil {
+		cb = func(key K, value *expirationLruItem[V]) {
+			onEvict(key, value.value)
+		}
+	}
+	core := expirable.NewLRU[K, *expirationLruItem[V]](size, cb, successTTL)
+	return &ExpirationLRU[K, V]{
+		core:       core,
+		successTTL: successTTL,
+		failedTTL:  failedTTL,
+		target:     target,
+	}
+}
+
+type expirationLruItem[V any] struct {
+	lock  sync.RWMutex
+	err   error
+	value V
+}
+
+type ExpirationLRU[K comparable, V any] struct {
+	lock       sync.Mutex
+	core       *expirable.LRU[K, *expirationLruItem[V]]
+	successTTL time.Duration
+	failedTTL  time.Duration
+	target     Target
+}
+
+func (x *ExpirationLRU[K, V]) GetBatch(keys []K, fetch func(keys []K) (map[K]V, error)) (map[K]V, error) {
+	//TODO implement me
+	panic("implement me")
+}
+
+func (x *ExpirationLRU[K, V]) Get(key K, fetch func() (V, error)) (V, error) {
+	x.lock.Lock()
+	v, ok := x.core.Get(key)
+	if ok {
+		x.lock.Unlock()
+		x.target.IncrGetSuccess()
+		v.lock.RLock()
+		defer v.lock.RUnlock()
+		return v.value, v.err
+	} else {
+		v = &expirationLruItem[V]{}
+		x.core.Add(key, v)
+		v.lock.Lock()
+		x.lock.Unlock()
+		defer v.lock.Unlock()
+		v.value, v.err = fetch()
+		if v.err == nil {
+			x.target.IncrGetSuccess()
+		} else {
+			x.target.IncrGetFailed()
+			x.core.Remove(key)
+		}
+		return v.value, v.err
+	}
+}
+
+func (x *ExpirationLRU[K, V]) Del(key K) bool {
+	x.lock.Lock()
+	ok := x.core.Remove(key)
+	x.lock.Unlock()
+	if ok {
+		x.target.IncrDelHit()
+	} else {
+		x.target.IncrDelNotFound()
+	}
+	return ok
+}
+
+func (x *ExpirationLRU[K, V]) SetHas(key K, value V) bool {
+	x.lock.Lock()
+	defer x.lock.Unlock()
+	if x.core.Contains(key) {
+		x.core.Add(key, &expirationLruItem[V]{value: value})
+		return true
+	}
+	return false
+}
+
+func (x *ExpirationLRU[K, V]) Set(key K, value V) {
+	x.lock.Lock()
+	defer x.lock.Unlock()
+	x.core.Add(key, &expirationLruItem[V]{value: value})
+}
+
+func (x *ExpirationLRU[K, V]) Stop() {
+}

pkg/localcache/lru/lru_lazy.go

@@ -0,0 +1,190 @@
+// Copyright © 2024 OpenIM. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package lru
+
+import (
+	"sync"
+	"time"
+
+	"github.com/hashicorp/golang-lru/v2/simplelru"
+)
+
+type lazyLruItem[V any] struct {
+	lock    sync.Mutex
+	expires int64
+	err     error
+	value   V
+}
+
+func NewLazyLRU[K comparable, V any](size int, successTTL, failedTTL time.Duration, target Target, onEvict EvictCallback[K, V]) *LazyLRU[K, V] {
+	var cb simplelru.EvictCallback[K, *lazyLruItem[V]]
+	if onEvict != nil {
+		cb = func(key K, value *lazyLruItem[V]) {
+			onEvict(key, value.value)
+		}
+	}
+	core, err := simplelru.NewLRU[K, *lazyLruItem[V]](size, cb)
+	if err != nil {
+		panic(err)
+	}
+	return &LazyLRU[K, V]{
+		core:       core,
+		successTTL: successTTL,
+		failedTTL:  failedTTL,
+		target:     target,
+	}
+}
+
+type LazyLRU[K comparable, V any] struct {
+	lock       sync.Mutex
+	core       *simplelru.LRU[K, *lazyLruItem[V]]
+	successTTL time.Duration
+	failedTTL  time.Duration
+	target     Target
+}
+
+func (x *LazyLRU[K, V]) Get(key K, fetch func() (V, error)) (V, error) {
+	x.lock.Lock()
+	v, ok := x.core.Get(key)
+	if ok {
+		x.lock.Unlock()
+		v.lock.Lock()
+		expires, value, err := v.expires, v.value, v.err
+		if expires != 0 && expires > time.Now().UnixMilli() {
+			v.lock.Unlock()
+			x.target.IncrGetHit()
+			return value, err
+		}
+	} else {
+		v = &lazyLruItem[V]{}
+		x.core.Add(key, v)
+		v.lock.Lock()
+		x.lock.Unlock()
+	}
+	defer v.lock.Unlock()
+	if v.expires > time.Now().UnixMilli() {
+		return v.value, v.err
+	}
+	v.value, v.err = fetch()
+	if v.err == nil {
+		v.expires = time.Now().Add(x.successTTL).UnixMilli()
+		x.target.IncrGetSuccess()
+	} else {
+		v.expires = time.Now().Add(x.failedTTL).UnixMilli()
+		x.target.IncrGetFailed()
+	}
+	return v.value, v.err
+}
+
+func (x *LazyLRU[K, V]) GetBatch(keys []K, fetch func(keys []K) (map[K]V, error)) (map[K]V, error) {
+	var (
+		err  error
+		once sync.Once
+	)
+
+	res := make(map[K]V)
+	queries := make([]K, 0, len(keys))
+
+	for _, key := range keys {
+		x.lock.Lock()
+		v, ok := x.core.Get(key)
+		x.lock.Unlock()
+		if ok {
+			v.lock.Lock()
+			expires, value, err1 := v.expires, v.value, v.err
+			v.lock.Unlock()
+			if expires != 0 && expires > time.Now().UnixMilli() {
+				x.target.IncrGetHit()
+				res[key] = value
+				if err1 != nil {
+					once.Do(func() {
+						err = err1
+					})
+				}
+				continue
+			}
+		}
+		queries = append(queries, key)
+	}
+
+	if len(queries) == 0 {
+		return res, err
+	}
+
+	values, fetchErr := fetch(queries)
+	if fetchErr != nil {
+		once.Do(func() {
+			err = fetchErr
+		})
+	}
+
+	for key, val := range values {
+		v := &lazyLruItem[V]{}
+		v.value = val
+
+		if err == nil {
+			v.expires = time.Now().Add(x.successTTL).UnixMilli()
+			x.target.IncrGetSuccess()
+		} else {
+			v.expires = time.Now().Add(x.failedTTL).UnixMilli()
+			x.target.IncrGetFailed()
+		}
+
+		x.lock.Lock()
+		x.core.Add(key, v)
+		x.lock.Unlock()
+		res[key] = val
+	}
+
+	return res, err
+}
+
+//func (x *LazyLRU[K, V]) Has(key K) bool {
+//	x.lock.Lock()
+//	defer x.lock.Unlock()
+//	return x.core.Contains(key)
+//}
+
+func (x *LazyLRU[K, V]) Set(key K, value V) {
+	x.lock.Lock()
+	defer x.lock.Unlock()
+	x.core.Add(key, &lazyLruItem[V]{value: value, expires: time.Now().Add(x.successTTL).UnixMilli()})
+}
+
+func (x *LazyLRU[K, V]) SetHas(key K, value V) bool {
+	x.lock.Lock()
+	defer x.lock.Unlock()
+	if x.core.Contains(key) {
+		x.core.Add(key, &lazyLruItem[V]{value: value, expires: time.Now().Add(x.successTTL).UnixMilli()})
+		return true
+	}
+	return false
+}
+
+func (x *LazyLRU[K, V]) Del(key K) bool {
+	x.lock.Lock()
+	ok := x.core.Remove(key)
+	x.lock.Unlock()
+	if ok {
+		x.target.IncrDelHit()
+	} else {
+		x.target.IncrDelNotFound()
+	}
+	return ok
+}
+
+func (x *LazyLRU[K, V]) Stop() {
+
+}

pkg/localcache/lru/lru_lazy_test.go

@@ -0,0 +1,113 @@
+// Copyright © 2024 OpenIM. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package lru
+
+import (
+	"fmt"
+	"hash/fnv"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+	"unsafe"
+)
+
+type cacheTarget struct {
+	getHit      int64
+	getSuccess  int64
+	getFailed   int64
+	delHit      int64
+	delNotFound int64
+}
+
+func (r *cacheTarget) IncrGetHit() {
+	atomic.AddInt64(&r.getHit, 1)
+}
+
+func (r *cacheTarget) IncrGetSuccess() {
+	atomic.AddInt64(&r.getSuccess, 1)
+}
+
+func (r *cacheTarget) IncrGetFailed() {
+	atomic.AddInt64(&r.getFailed, 1)
+}
+
+func (r *cacheTarget) IncrDelHit() {
+	atomic.AddInt64(&r.delHit, 1)
+}
+
+func (r *cacheTarget) IncrDelNotFound() {
+	atomic.AddInt64(&r.delNotFound, 1)
+}
+
+func (r *cacheTarget) String() string {
+	return fmt.Sprintf("getHit: %d, getSuccess: %d, getFailed: %d, delHit: %d, delNotFound: %d", r.getHit, r.getSuccess, r.getFailed, r.delHit, r.delNotFound)
+}
+
+func TestName(t *testing.T) {
+	target := &cacheTarget{}
+	l := NewSlotLRU[string, string](100, func(k string) uint64 {
+		h := fnv.New64a()
+		h.Write(*(*[]byte)(unsafe.Pointer(&k)))
+		return h.Sum64()
+	}, func() LRU[string, string] {
+		return NewExpirationLRU[string, string](100, time.Second*60, time.Second, target, nil)
+	})
+	//l := NewInertiaLRU[string, string](1000, time.Second*20, time.Second*5, target)
+
+	fn := func(key string, n int, fetch func() (string, error)) {
+		for i := 0; i < n; i++ {
+			//v, err := l.Get(key, fetch)
+			//if err == nil {
+			//	t.Log("key", key, "value", v)
+			//} else {
+			//	t.Error("key", key, err)
+			//}
+			v, err := l.Get(key, fetch)
+			//time.Sleep(time.Second / 100)
+			func(v ...any) {}(v, err)
+		}
+	}
+
+	tmp := make(map[string]struct{})
+
+	var wg sync.WaitGroup
+	for i := 0; i < 10000; i++ {
+		wg.Add(1)
+		key := fmt.Sprintf("key_%d", i%200)
+		tmp[key] = struct{}{}
+		go func() {
+			defer wg.Done()
+			//t.Log(key)
+			fn(key, 10000, func() (string, error) {
+
+				return "value_" + key, nil
+			})
+		}()
+
+		//wg.Add(1)
+		//go func() {
+		//	defer wg.Done()
+		//	for i := 0; i < 10; i++ {
+		//		l.Del(key)
+		//		time.Sleep(time.Second / 3)
+		//	}
+		//}()
+	}
+	wg.Wait()
+	t.Log(len(tmp))
+	t.Log(target.String())
+
+}

pkg/localcache/lru/lru_slot.go

@@ -0,0 +1,82 @@
+// Copyright © 2024 OpenIM. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package lru
+
+func NewSlotLRU[K comparable, V any](slotNum int, hash func(K) uint64, create func() LRU[K, V]) LRU[K, V] {
+	x := &slotLRU[K, V]{
+		n:     uint64(slotNum),
+		slots: make([]LRU[K, V], slotNum),
+		hash:  hash,
+	}
+	for i := 0; i < slotNum; i++ {
+		x.slots[i] = create()
+	}
+	return x
+}
+
+type slotLRU[K comparable, V any] struct {
+	n     uint64
+	slots []LRU[K, V]
+	hash  func(k K) uint64
+}
+
+func (x *slotLRU[K, V]) GetBatch(keys []K, fetch func(keys []K) (map[K]V, error)) (map[K]V, error) {
+	var (
+		slotKeys = make(map[uint64][]K)
+		kVs       = make(map[K]V)
+	)
+
+	for _, k := range keys {
+		index := x.getIndex(k)
+		slotKeys[index] = append(slotKeys[index], k)
+	}
+
+	for k, v := range slotKeys {
+		batches, err := x.slots[k].GetBatch(v, fetch)
+		if err != nil {
+			return nil, err
+		}
+		for key, value := range batches {
+			kVs[key] = value
+		}
+	}
+	return kVs, nil
+}
+
+func (x *slotLRU[K, V]) getIndex(k K) uint64 {
+	return x.hash(k) % x.n
+}
+
+func (x *slotLRU[K, V]) Get(key K, fetch func() (V, error)) (V, error) {
+	return x.slots[x.getIndex(key)].Get(key, fetch)
+}
+
+func (x *slotLRU[K, V]) Set(key K, value V) {
+	x.slots[x.getIndex(key)].Set(key, value)
+}
+
+func (x *slotLRU[K, V]) SetHas(key K, value V) bool {
+	return x.slots[x.getIndex(key)].SetHas(key, value)
+}
+
+func (x *slotLRU[K, V]) Del(key K) bool {
+	return x.slots[x.getIndex(key)].Del(key)
+}
+
+func (x *slotLRU[K, V]) Stop() {
+	for _, slot := range x.slots {
+		slot.Stop()
+	}
+}

pkg/localcache/option.go

@@ -0,0 +1,136 @@
+// Copyright © 2024 OpenIM. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package localcache
+
+import (
+	"context"
+	"time"
+
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/localcache/lru"
+)
+
+func defaultOption() *option {
+	return &option{
+		localSlotNum:    500,
+		localSlotSize:   20000,
+		linkSlotNum:     500,
+		expirationEvict: false,
+		localSuccessTTL: time.Minute,
+		localFailedTTL:  time.Second * 5,
+		delFn:           make([]func(ctx context.Context, key ...string), 0, 2),
+		target:          EmptyTarget{},
+	}
+}
+
+type option struct {
+	localSlotNum  int
+	localSlotSize int
+	linkSlotNum   int
+	// expirationEvict: true means that the cache will be actively cleared when the timer expires,
+	// false means that the cache will be lazily deleted.
+	expirationEvict bool
+	localSuccessTTL time.Duration
+	localFailedTTL  time.Duration
+	delFn           []func(ctx context.Context, key ...string)
+	target          lru.Target
+}
+
+type Option func(o *option)
+
+func WithExpirationEvict() Option {
+	return func(o *option) {
+		o.expirationEvict = true
+	}
+}
+
+func WithLazy() Option {
+	return func(o *option) {
+		o.expirationEvict = false
+	}
+}
+
+func WithLocalDisable() Option {
+	return WithLinkSlotNum(0)
+}
+
+func WithLinkDisable() Option {
+	return WithLinkSlotNum(0)
+}
+
+func WithLinkSlotNum(linkSlotNum int) Option {
+	return func(o *option) {
+		o.linkSlotNum = linkSlotNum
+	}
+}
+
+func WithLocalSlotNum(localSlotNum int) Option {
+	return func(o *option) {
+		o.localSlotNum = localSlotNum
+	}
+}
+
+func WithLocalSlotSize(localSlotSize int) Option {
+	return func(o *option) {
+		o.localSlotSize = localSlotSize
+	}
+}
+
+func WithLocalSuccessTTL(localSuccessTTL time.Duration) Option {
+	if localSuccessTTL < 0 {
+		panic("localSuccessTTL should be greater than 0")
+	}
+	return func(o *option) {
+		o.localSuccessTTL = localSuccessTTL
+	}
+}
+
+func WithLocalFailedTTL(localFailedTTL time.Duration) Option {
+	if localFailedTTL < 0 {
+		panic("localFailedTTL should be greater than 0")
+	}
+	return func(o *option) {
+		o.localFailedTTL = localFailedTTL
+	}
+}
+
+func WithTarget(target lru.Target) Option {
+	if target == nil {
+		panic("target should not be nil")
+	}
+	return func(o *option) {
+		o.target = target
+	}
+}
+
+func WithDeleteKeyBefore(fn func(ctx context.Context, key ...string)) Option {
+	if fn == nil {
+		panic("fn should not be nil")
+	}
+	return func(o *option) {
+		o.delFn = append(o.delFn, fn)
+	}
+}
+
+type EmptyTarget struct{}
+
+func (e EmptyTarget) IncrGetHit() {}
+
+func (e EmptyTarget) IncrGetSuccess() {}
+
+func (e EmptyTarget) IncrGetFailed() {}
+
+func (e EmptyTarget) IncrDelHit() {}
+
+func (e EmptyTarget) IncrDelNotFound() {}

pkg/localcache/tool.go

@@ -0,0 +1,23 @@
+// Copyright © 2024 OpenIM. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package localcache
+
+func AnyValue[V any](v any, err error) (V, error) {
+	if err != nil {
+		var zero V
+		return zero, err
+	}
+	return v.(V), nil
+}