cache

Author: coder2z

xcache/basis.go

@@ -13,8 +13,9 @@ type (
 	}
 
 	node struct {
-		data   []byte
-		expire time.Duration
+		data      []byte
+		expire    time.Duration
+		creatTime time.Time
 	}
 )
 
@@ -37,7 +38,7 @@ func (b basis) GetE(key string) ([]byte, error) {
 	if !ok {
 		return nil, nilError
 	}
-	if b.checkExpire(node.expire) {
+	if b.checkExpire(node) {
 		b.doDel(key)
 		return nil, nilError
 	}
@@ -75,8 +76,9 @@ func (b basis) GetWithCreate(key string, h Handle) []byte {
 
 func (b basis) doSetWithData(key string, data []byte, expire time.Duration) {
 	b.data[key] = node{
-		data:   data,
-		expire: expire,
+		creatTime: time.Now(),
+		data:      data,
+		expire:    expire,
 	}
 }
 
@@ -100,11 +102,11 @@ func (b basis) IsExist(key string) bool {
 	return b.doIsExist(key) == nilError
 }
 
-func (b basis) checkExpire(ts time.Duration) bool {
-	if ts.Nanoseconds() == 0 {
+func (b basis) checkExpire(n node) bool {
+	if n.expire == 0 {
 		return false
 	}
-	return time.Now().UnixNano() > ts.Nanoseconds()
+	return time.Now().After(n.creatTime.Add(n.expire))
 }
 
 func (b basis) doIsExist(key string) error {

xcache/basis_test.go

@@ -1,31 +1,31 @@
 package xcache
 
 import (
+	"fmt"
 	"testing"
 	"time"
 )
 
-type testdata struct {
-}
+type testdata struct{}
 
 func (t testdata) Create() ([]byte, error) {
-	return []byte("静安里看风景阿卡丽大家啊就完蛋了卡"), nil
+	return []byte("test"), nil
 }
 
 func (t testdata) Expire() time.Duration {
-	return 0
+	return time.Second * 3
 }
 
-func TestName(t *testing.T) {
-	b := NewBasis()
+func BenchmarkBasis(b *testing.B) {
+	b.ReportAllocs()
+	b.StopTimer()
+	c := NewBasis()
+	b.StartTimer()
 
-	err := b.Set("key", new(testdata))
-	if err != nil {
-		return
-	}
-	data, err := b.Get("key")
-	if err != nil {
-		return
+	for i := 0; i < b.N; i++ {
+		_ = c.Set(fmt.Sprintf("key_%d", i), new(testdata))
+		if string(c.Get(fmt.Sprintf("key_%d", i))) != "test" {
+			b.Error("data error ")
+		}
 	}
-	t.Log(string(data))
 }

xcache/lru/lru.go

@@ -0,0 +1,79 @@
+package lru
+
+import "container/list"
+
+// Cache is a LRU cache. It is not safe for concurrent access.
+type Cache struct {
+	maxBytes int64
+	nbytes   int64
+	ll       *list.List
+	cache    map[string]*list.Element
+	// optional and executed when an entry is purged.
+	OnEvicted func(key string, value Value)
+}
+
+type entry struct {
+	key   string
+	value Value
+}
+
+// Value use Len to count how many bytes it takes
+type Value interface {
+	Len() int
+}
+
+// New is the Constructor of Cache
+func New(maxBytes int64, onEvicted func(string, Value)) *Cache {
+	return &Cache{
+		maxBytes:  maxBytes,
+		ll:        list.New(),
+		cache:     make(map[string]*list.Element),
+		OnEvicted: onEvicted,
+	}
+}
+
+// Add adds a value to the cache.
+func (c *Cache) Add(key string, value Value) {
+	if ele, ok := c.cache[key]; ok {
+		c.ll.MoveToFront(ele)
+		kv := ele.Value.(*entry)
+		c.nbytes += int64(value.Len()) - int64(kv.value.Len())
+		kv.value = value
+	} else {
+		ele := c.ll.PushFront(&entry{key, value})
+		c.cache[key] = ele
+		c.nbytes += int64(len(key)) + int64(value.Len())
+	}
+	for c.maxBytes != 0 && c.maxBytes < c.nbytes {
+		c.RemoveOldest()
+	}
+}
+
+// Get look ups a key's value
+func (c *Cache) Get(key string) (value Value, ok bool) {
+	if ele, ok := c.cache[key]; ok {
+		c.ll.MoveToFront(ele)
+		kv := ele.Value.(*entry)
+		return kv.value, true
+	}
+	return
+}
+
+// RemoveOldest removes the oldest item
+func (c *Cache) RemoveOldest() {
+	ele := c.ll.Back()
+	if ele != nil {
+		c.ll.Remove(ele)
+		kv := ele.Value.(*entry)
+		delete(c.cache, kv.key)
+		c.nbytes -= int64(len(kv.key)) + int64(kv.value.Len())
+		if c.OnEvicted != nil {
+			c.OnEvicted(kv.key, kv.value)
+		}
+	}
+}
+
+// Len the number of cache entries
+func (c *Cache) Len() int {
+	return c.ll.Len()
+}