go实现一个内存缓存系统的示例代码

setmemory(size string) bool
	set(key string, val interface{}, expire time.duration) bool
	get(key string) (interface{}, bool)
	del(key string) bool
	exists(key string) bool
	flush() bool
	keys() int64

package cache
import "time"
type cache interface {
	setmemory(size string) bool
	set(key string, val interface{}, expire time.duration) bool
	get(key string) (interface{}, bool)
	del(key string) bool
	exists(key string) bool
	flush() bool
	keys() int64
}

package cache

import (
	"fmt"
	"sync"
	"time"
)

type memcache struct {
	//最大内存
	maxmemorysize int64
	// 当前已使用的内存
	currmemorysize int64
	// 最大内存字符串表示
	maxmemorysizestr string
	// 缓存键值对
	values map[string]*memcachevalue
	// 读写锁
	lock sync.rwmutex
	//设置清除过期缓存的时间间隔
	clearexpiretime time.duration
}

type memcachevalue struct {
	//value 值
	val interface{}
	// 过期时间
	expiretime time.time
	//有效时间
	expire time.duration
	//value 大小
	size int64
}

func newmemcache() cache {
	mc := &memcache{
		clearexpiretime: time.second * 10,
		values:          make(map[string]*memcachevalue),
	}
	go mc.clearexpireitm()
	return mc
}

// setmemory size 1kb 100kb 1m 2m 1gb
func (mc *memcache) setmemory(size string) bool {
	mc.maxmemorysize, mc.maxmemorysizestr = parsesize(size)
	return true
}

// set 设置缓存
func (mc *memcache) set(key string, val interface{}, expire time.duration) bool {
	mc.lock.lock()
	defer mc.lock.unlock()
	v := &memcachevalue{val: val, expiretime: time.now().add(expire),
		expire: expire,
		size:   getvalsize(val)}
	//mc.values[key] = v
	mc.del(key)
	mc.add(key, v)
	if mc.currmemorysize > mc.maxmemorysize {
		mc.del(key)
		panic(fmt.sprintf("max memory size %d", mc.maxmemorysize))
	}
	return true
}

func (mc *memcache) get(key string) (*memcachevalue, bool) {
	val, ok := mc.values[key]
	return val, ok
}

func (mc *memcache) del(key string) {
	tmp, ok := mc.get(key)
	if ok && tmp != nil {
		mc.currmemorysize -= tmp.size
		delete(mc.values, key)
	}
}

func (mc *memcache) add(key string, val *memcachevalue) {
	mc.values[key] = val
	mc.currmemorysize += val.size
}

// get 获取缓存值
func (mc *memcache) get(key string) (interface{}, bool) {
	mc.lock.rlock()
	defer mc.lock.runlock()
	mcv, ok := mc.get(key)
	if ok {
		if mcv.expire != 0 && mcv.expiretime.before(time.now()) {
			mc.del(key)
			return nil, false
		}
		return mcv.val, ok
	}
	return nil, false
}

// del 删除缓存值
func (mc *memcache) del(key string) bool {
	mc.lock.lock()
	defer mc.lock.unlock()
	mc.del(key)
	return true
}

func (mc *memcache) exists(key string) bool {
	mc.lock.rlock()
	defer mc.lock.runlock()
	_, ok := mc.get(key)
	return ok
}

func (mc *memcache) flush() bool {
	mc.lock.lock()
	defer mc.lock.unlock()
	mc.values = make(map[string]*memcachevalue, 0)
	mc.currmemorysize = 0
	return true
}

func (mc *memcache) keys() int64 {
	mc.lock.rlock()
	defer mc.lock.runlock()
	return int64(len(mc.values))
}

func (mc *memcache) clearexpireitm() {
	ticker := time.newticker(mc.clearexpiretime)
	defer ticker.stop()
	for {
		select {
		case <-ticker.c:
			for key, v := range mc.values {
				if v.expire != 0 && time.now().after(v.expiretime) {
					mc.lock.lock()
					mc.del(key)
					mc.lock.unlock()
				}
			}
		}
	}
}

//
//var cache = newmemcache()
//
//func set(key string, val interface{}) bool {
//
//	return false
//}

package cache

import (
	"log"
	"regexp"
	"strconv"
	"strings"
)

const (
	b = 1 << (iota * 10)
	kb
	mb
	gb
	tb
	pb
)

func parsesize(size string) (int64, string) {

	//默认大小为 100m
	re, _ := regexp.compile("[0-9]+")
	unit := string(re.replaceall([]byte(size), []byte("")))
	num, _ := strconv.parseint(strings.replace(size, unit, "", 1), 10, 64)
	unit = strings.toupper(unit)
	var bytenum int64 = 0
	switch unit {
	case "b":
		bytenum = num
		break
	case "kb":
		bytenum = num * kb
		break
	case "mb":
		bytenum = num * mb
		break
	case "gb":
		bytenum = num * gb
		break
	case "tb":
		bytenum = num * tb
		break
	case "pb":
		bytenum = num * pb
		break
	default:
		num = 0
		bytenum = 0

	}
	if num == 0 {
		log.println("parsesize 仅支持b，kb,mb,gb,tb,pb")
		num = 100 * mb
		bytenum = num
		unit = "mb"
	}
	sizestr := strconv.formatint(num, 10) + unit
	return bytenum, sizestr

}

func getvalsize(val interface{}) int64 {
	return 0
}

package server

import (
	"go_lang_pro/cache"
	"time"
)

type cacheserver struct {
	memcache cache.cache
}

func newmemorycache() *cacheserver {
	return &cacheserver{
		memcache: cache.newmemcache(),
	}
}

func (cs *cacheserver) setmemory(size string) bool {
	return cs.memcache.setmemory(size)
}

func (cs *cacheserver) set(key string, val interface{}, expire ...time.duration) bool {
	expirets := time.second * 0
	if len(expire) > 0 {
		expirets = expire[0]
	}
	return cs.memcache.set(key, val, expirets)
}

func (cs *cacheserver) get(key string) (interface{}, bool) {
	return cs.memcache.get(key)
}
func (cs *cacheserver) del(key string) bool {
	return cs.memcache.del(key)
}

func (cs *cacheserver) exists(key string) bool {
	return cs.memcache.exists(key)
}

func (cs *cacheserver) flush() bool {
	return cs.memcache.flush()
}

func (cs *cacheserver) keys() int64 {
	return cs.memcache.keys()
}

package main

import (
	"go_lang_pro/cache"
	"time"
)

func main() {

	cache := cache.newmemcache()
	cache.setmemory("100mb")
	cache.set("int", 1, time.second)
	cache.set("bool", false, time.second)
	cache.set("data", map[string]interface{}{"a": 1}, time.second)
	cache.get("int")
	cache.del("int")
	cache.flush()
	cache.keys()

}