golang实现一个简易的缓存系统

项目结构:
├── README.md
├── cache
│   ├── cache.go
│   ├── cache_store.go
│   ├── iCache.go
│   ├── mcache.go
│   └── mcache_test.go
├── cache_server
│   ├── cacheServer.go
│   └── cacheServer_test.go
├── constant
│   └── constant.go
├── cuserror
│   └── error.go
├── go.mod
├── logger
│   ├── console.go
│   ├── file.go
│   ├── file_test.go
│   ├── iLogger.go
│   ├── logger.go
│   └── logger_test.go
├── main.go
└── util
    ├── util.go
    └── util_test.go

6 directories, 20 files


package cache

import "time"

/**
该程序需要满⾜足以下要求:
1. 支持设定过期时间，精度为秒级。
2. 支持设定最⼤大内存，当内存超出时候做出合理理的处理理。
3. 支持并发安全。
4. 为简化编程细节，无需实现数据落地。
 */

/**
⽀支持过期时间和最⼤大内存⼤大⼩小的的内存缓存库。
*/
type ICache interface {
	//size 是⼀一个字符串串。⽀支持以下参数: 1KB，100KB，1MB，2MB，1GB 等
	SetMaxMemory(size string) bool
	// 设置⼀一个缓存项，并且在expire时间之后过期
	Set(key string, val interface{}, expire time.Duration) // 获取⼀一个值
	Get(key string) (interface{}, bool)
	// 删除⼀一个值
	Del(key string) bool
	// 检测⼀一个值 是否存在
	Exists(key string) bool
	// 情况所有值
	Flush() bool
	// 返回所有的key 多少
	Keys() int64
	//清理过期的节点
	ClearExpireNode()
}


package cache


import (
	"fmt"
	"time"
)

/**
 * 缓存存在结构(使用单链表实现)
 */
type mNode struct{
	Key string  //键
	Value interface{} //值
	InsertTime time.Time //记录插入时间
	Expire time.Duration //过期间隔(单位为秒)
	Next *mNode //定义一地址域(指向下一个)
}

type linkedList struct {
	firstNode *mNode //头结点
}

func NewLinkedList() *linkedList{
	return &linkedList{}
}

//判断是否为空的单链接表
func (link *linkedList) isEmpty() bool {
	if link.firstNode == nil {
		return true
	}
	return false
}


//返回总数
func (link *linkedList) Size() int64{
	first := link.firstNode //获取链表的头结点
	var count  int64 = 0 //定义一个计数器
	for first != nil {
		//如果节点不为空，则count++
		count++
		first = first.Next
	}
	return count
}

//从表头添加元素
func (link *linkedList)Add(key string,value interface{},expire time.Duration) bool{

	node := &mNode{
		Key:key,
		Value: value,
		Expire:expire,
		InsertTime:time.Now(),
	}
	node.Next = link.firstNode
	link.firstNode = node
	return true
}

//在尾部添加数据,需要从头部开始遍历，直到nil
func (link *linkedList) Append(key string,value interface{},expire time.Duration) bool{
	newNode := &mNode{
		Key:key,
		Value:value,
		Expire:expire,
		InsertTime:time.Now(),
	}
	node := link.firstNode
	//首部是空
	if node == nil {
		link.firstNode = newNode
		return  true
	}else {
		for node.Next != nil {
			node = node.Next
		}
		//已经到最后
		node.Next = newNode
		return  true
	}
	return  false
}

//在指定位置插入
func (link *linkedList)Insert(index int64,key string,value interface{},expire time.Duration)  bool {

	newMode := &mNode{
		Key:key,
		Value:value,
		Expire:expire,
	}
	node := link.firstNode
	if index < 0 {
		//index小于0就放在首部
		link.Add(key,value,expire)
		return  true
	} else if index > link.Size(){
		//index大于 长度就放在尾部
		link.Append(key,value,expire)
		return  true
	}else {
		var count int64 = 0
		//找到index之前的元素
		for count < (index -1 ){
			node = node.Next
			count +=1
		}
		//已经找到index之前的元素
		newMode.Next = node.Next
		node.Next = newMode
		return  true
	}
	return  false
}

//删除指定元素，从首部遍历该元素删除，并且需要维护指针
func (link *linkedList) Delete(key interface{})  bool {

	node := link.firstNode
	//如果是首部
	if node != nil && node.Key == key {
		link.firstNode = node.Next
	}else{
		for node != nil  &&  node.Next != nil {
			//找到，改指针
			if node.Next.Key == key{
				node.Next = node.Next.Next
				return  true
			}else{
				node = node.Next
			}
		}
	}
	return false
}

//循环遍历链表
func (link *linkedList) forEachLink()  {

	node := link.firstNode
	for node != nil  {
		str := fmt.Sprintf("{\"%v\":%v}",node.Key,node.Value)
		fmt.Printf("%v\n",str)
		node = node.Next
	}
}


func (link *linkedList) Get(key string) *mNode  {

	node := link.firstNode
	for node != nil  {
		if node.Key == key {
			return  node
		}
		node = node.Next
	}
	return nil
}


func (link *linkedList) IsExists(key string) bool  {

	node := link.firstNode
	for node != nil  {
		if node.Key == key {
			return  true
		}
		node = node.Next
	}
	return false
}

//检查这个key是否过期
func (link *linkedList) isExpire(key string) (string,bool)  {

	node := link.firstNode
	for node != nil  {
		if node.Key == key {
			return key,time.Now().Sub(node.InsertTime) > node.Expire
		}
		node = node.Next
	}
	return key,false
}

func (link *linkedList) Empty() bool{
	node := link.firstNode
	for node != nil  {
		link.Delete(node.Key)
		node = node.Next
		//node = nil
	}

	return true
}

//获取所有过期的keys
func (link *linkedList) GetExpireKeys() (keys []string ) {

	node := link.firstNode
	for node != nil  {
		if time.Now().Sub(node.InsertTime) > node.Expire {
			keys = append(keys,node.Key)
		}
		node = node.Next
	}
	return
}

package cache

import (
	"cache-system/logger"
	"cache-system/util"
	"sync"
	"time"
)

type Cache struct {
	SizeStr string //1KB，100KB，1MB，2MB，1GB
	size int64
	cookieMap *linkedList //存在cache
	rwLock sync.RWMutex //读写所
	Interval int // 多长时间执行一次清理任务，操作单位秒
}

func NewCache(size string,interval int) ICache{

	return  &Cache{
		SizeStr:   size,
		size:      util.ParseSize(size),
		cookieMap: NewLinkedList(),
		Interval:interval,
	}
}

func (c *Cache)SetMaxMemory(size string) bool  {
	c.rwLock.RLock()
	defer c.rwLock.Unlock()
	c.SizeStr = size
	c.size = util.ParseSize(size)
	return true
}


// 设置⼀一个缓存项，并且在expire时间之后过期
func (c *Cache)Set(key string, val interface{}, expire time.Duration) {
	c.rwLock.Lock() //使用互斥锁来保证写的数据确证性
	defer c.rwLock.Unlock()
	if c.Exists(key){
		c.cookieMap.Delete(key)
	}

	c.cookieMap.Add(key,val,expire) //Add方法在头部插入
}

func (c *Cache)Get(key string) (interface{}, bool){
	c.rwLock.RLock()
	defer c.rwLock.RUnlock()
	var t bool = false
	cache := c.cookieMap.Get(key)
	if cache != nil {
		t = true
	}
	if cache != nil {
		return  cache.Value,t
	}
	return nil,false
}

// 删除一个值
func (c *Cache)Del(key string) bool{
	c.rwLock.Lock()
	defer c.rwLock.Unlock()
	return  c.cookieMap.Delete(key)
}

// 检测一个值是否存在
func (c *Cache)Exists(key string) bool{
	return  c.cookieMap.IsExists(key)
}

// 清空所有值
func (c *Cache)Flush() bool{
	c.rwLock.Lock()
	defer c.rwLock.Unlock()
	return  c.cookieMap.Empty()
}

// 返回所有的key 多少
func (c *Cache)Keys() int64{
	c.rwLock.Lock()
	defer c.rwLock.Unlock()
	return  c.cookieMap.Size()
}


func (c *Cache) ClearExpireNode(){
	for{
		logger.Info("exec clear expire key task")
		select {
		case <-time.After(time.Duration(c.Interval) *time.Second):
			if keys :=  c.cookieMap.GetExpireKeys(); len(keys) != 0 {
				for _,key := range keys{
					logger.Info("clear expire key:%v",key)
					c.Del(key)
				}
			}
		}
	}
}



package cache

import (
	"cache-system/logger"
	"time"
)

var cache ICache

var currentSize int64

func InitMCache()  {
	//默认初始化一个cache实例，并设置可用存储不能过物理内存可用容量和总容量
	logger.Info("init cache instance,cap:%v","256MB")
	cache = NewCache("256MB",5) //可用存储容量
	//go clearExpireNode() //执行清理任务
}


func SetMaxMemory(size string) bool{
	logger.Info("exec cache.SetMaxMemory,value:%v",size)
	return  cache.SetMaxMemory(size)
}

// 设置⼀一个缓存项，并且在expire时间之后过期
func Set(key string, val interface{}, expire int64){

	var ex time.Duration = time.Duration(expire* int64(1000000000))
	logger.Info("exec cache.Set,key:%v,value:%v,expire:%v",key,val,expire)
	cache.Set(key,val,ex)
}

func Get(key string) (interface{}, bool) {
	v,t := cache.Get(key)
	logger.Info("exec cache.Get,in-value:%v,out-value:%v,status:%v",key,v,t)
	return v,t
}

// 删除⼀个值
func Del(key string) bool {
	t := cache.Del(key)
	logger.Info("exec cache.Del, value:%v",key)
	return  t
}

// 检测⼀个值 是否存在
func Exists(key string) bool {
	t := cache.Exists(key)
	logger.Info("exec cache.Exists,value:%v,status:%v",key,t)
	return t
}

// 情况所有值
func Flush() bool {
	t := cache.Flush()
	logger.Info("exec cache.Flush(),ret-value:%v",t)
	return t
}

// 返回所有的key 多少
func Keys() int64 {
	t :=  cache.Keys()
	logger.Info("exec cache.Keys, ret-value:%v",t)
	return t
}

func ClearExpireNode(){
	cache.ClearExpireNode()
}


package cache

import (
	"cache-system/logger"
	"fmt"
	"runtime"
	"testing"
	"time"
)

func init() {
	config := make(map[string]string,1)
	config["log_level"] = "debug"

	logger.InitLogger("console",config)
	InitMCache()
}

func TestSet(t *testing.T) {
	Set("name","mfz",5) //10秒后过期
	time.Sleep(5*time.Second)
	Set("age","22",25) //10秒后过期
	time.Sleep(5*time.Second)
	Set("work","it-dev",40) //10秒后过期
}

func TestGet(t *testing.T) {
	value,ok := Get("name")
	if ok {
		fmt.Printf("name:%v\n",value)
	}else {
		t.Errorf("Get key:%v is not exists","name")
	}
	select {

	}
}



func MStat(t *testing.T)  {

	type MemStatus struct {
		All  uint32 `json:"all"`
		Used uint32 `json:"used"`
		Free uint32 `json:"free"`
		Self uint64 `json:"self"`
	}

	memStat := new(runtime.MemStats)
	//自身占用
	for i:=0; i < 200000; i++{

		runtime.ReadMemStats(memStat)
		mem := MemStatus{}
		mem.Self = memStat.Alloc

		time.Sleep(1*time.Second)
	}

}

package main

import (
	"cache-system/logger"
	"fmt"
	"math/rand"
	"time"
)
import "cache-system/cache"

func init(){
	rand.Seed(time.Now().UnixNano()) //初始化随机种子
}
func InitLog(){
	config := make(map[string]string,1)
	config["log_level"] = "debug"
	logger.InitLogger("console",config)
}

func InitCache(){
	cache.InitMCache()
}

func main(){
	InitLog() //初始化日志实例
	InitCache() //初化缓存实例

	for i:= 0; i < 500; i++{
		cache.Set("name:"+fmt.Sprintf("%d",i+1),"tom:"+fmt.Sprintf("%d",i+1),rand.Int63n(10000))
		//time.Sleep(200*time.Millisecond)
	}

	/*
	time.Sleep(200*time.Millisecond)
	cache.Flush()
	time.Sleep(200*time.Millisecond)
	fmt.Printf("get cache table size:%d\n",cache.Keys())
	time.Sleep(200*time.Millisecond)
    */

	fmt.Printf("get cache table size:%d\n",cache.Keys())
	//查询name100 key的值
	val,ok :=cache.Get("name:100")
	fmt.Printf("get name:100 value:%v, status:%v\n",val,ok)
	//删除name100 key
	cache.Del("name:100")
	//查询name100 key是否删除成功
	fmt.Printf("get name:100 key:%v\n",cache.Exists("name:100"))
	time.Sleep(2*time.Second) //等待两秒后开清理过期任务
	go cache.ClearExpireNode()

	select { //阻塞等待

	}
}