iedc-go/cache_memory.go

package hotime

import (
	"time"
	"sync"
)

type CacheMemory struct {
	Time int64
	Map
	contextBase
	mutex *sync.RWMutex
}

//获取Cache键只能为string类型
func (this *CacheMemory) get(key string) interface{} {
	this.Error.SetError(nil)
	if this.Map[key] == nil {
		return nil
	}
	data := this.Map.Get(key, &this.Error).(cacheData)
	if this.GetError() != nil {
		return nil
	}
	//data:=cacheMap[key];
	if data.time <= time.Now().Unix() {
		delete(this.Map, key)
		return nil
	}
	return data.data
}

func (this *CacheMemory)refreshMap(){

	go func() {
		this.mutex.Lock()
		defer this.mutex.Unlock()
		for key,v:=range this.Map{
			data:=v.(cacheData)
			if data.time <= time.Now().Unix() {
				delete(this.Map, key)
			}
		}

	}()



}

//key value ,时间为时间戳
func (this *CacheMemory) set(key string, value interface{}, time int64) {
	this.Error.SetError(nil)
	var data cacheData
	dd := this.Map.Get(key, &this.Error)

	if dd == nil {
		data = cacheData{}
	} else {
		data = dd.(cacheData)
	}

	data.time = time
	data.data = value

	if this.Map == nil {
		this.Map = Map{}
	}
	this.Map.Put(key, data)
}

func (this *CacheMemory) delete(key string) {

	delete(this.Map, key)
}

func (this *CacheMemory) Cache(key string, data ...interface{}) *Obj {


		x:=RandX(1,100000)
		if x>99950{
			this.refreshMap()
		}
		if this.mutex==nil{
			this.mutex=&sync.RWMutex{}
		}

		reData:= &Obj{}


		if len(data) == 0 {
			this.mutex.RLock()
			reData.Data=this.get(key)
			 this.mutex.RUnlock()
			return reData
		}
		tim := time.Now().Unix()

		if len(data) == 1 && data[0] == nil {
			this.mutex.Lock()
			this.delete(key)
			this.mutex.Unlock()
			return reData
		}

		if len(data) == 1 {

			if this.Time == 0 {
				this.Time = Config.GetInt64("cacheShortTime")
			}

			tim += this.Time
		}
		if len(data) == 2 {
			this.Error.SetError(nil)
			tempt := ObjToInt64(data[1], &this.Error)
			if this.GetError() == nil {

				tim = tim + tempt

			}
		}
		this.mutex.Lock()
		this.set(key, data[0], tim)
		this.mutex.Unlock()
		return reData

}