golang开发缓存组件

转载 2016年12月06日 17:08:02


花了一天时间看了下实验楼的cache组件,使用golang编写的,收获还是蛮多的,缓存组件的设计其实挺简单的,主要思路或者设计点如下:

  • 全局struct对象:用来做缓存(基于该struct实现增删改查基本操作)
  • 定时gc功能(其实就是定时删除struct对象中过期的缓存对):刚好用上golang的ticker外加channel控制实现
  • 支持缓存写文件及从文件读缓存:其实就是将这里的key-value数据通过gob模块进行一次编解码操作
  • 并发读写:上锁(golang支持读写锁,一般使用时在被操作的struct对象里面声明相应的锁,即sync.RWMutex,操作之前先上锁,之后解锁即可)

其实大概就是这么多,下面来分解下:

1、cache组件

要保存数据到缓存(即内存中),先要设计数据结构,cache一般都有过期时间,抽象的struct如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
type Item struct {
    Object     interface{} //数据项
    Expiration int64       //数据项过期时间(0永不过期)
}
 
type Cache struct {
    defaultExpiration time.Duration //如果数据项没有指定过期时使用
    items             map[string]Item
    mu                sync.RWMutex  //读写锁
    gcInterval        time.Duration //gc周期
    stopGc            chan bool     //停止gc管道标识
}

其中,Cache struct为全局缓存对象,缓存的key-value类型为Item,其中包含Object类型、Expiration类型,Object类型设计为interface{}就是为了可以缓存任意数据。

2、过期处理

下面是判断item中的某项是否过期:

?
1
2
3
4
5
6
func (item Item) IsExpired() bool {
    if item.Expiration == 0 {
        return false
    }
    return time.Now().UnixNano() > item.Expiration //如果当前时间超则过期
}

3、定时gc

想要实现定时功能,要用到golang的time包,使用NewTicker声明一个ticker类型,再使用for循环读取ticker.C数据,循环一次则取一次数据,进行一次DeleteExpired操作,Cache中的stopGc用于结束ticker,这样整个gcLoop()便会停止,使用select监听通道数据分别处理如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
//循环gc
func (c *Cache) gcLoop() {
    ticker := time.NewTicker(c.gcInterval) //初始化一个定时器
    for {
        select {
        case <-ticker.C:
            c.DeleteExpired()
        case <-c.stopGc:
            ticker.Stop()
            return
        }
    }
}

4、缓存写文件及从文件读缓存

这里要使用到golang自带gob包,gob主要用于诸如远程调用等过程的参数编解码,相比json传输而言,大数据量下效率明显占优。gob的使用一般流程是:声明一个Encoder/Decoder、然后调用Encode/Decode方法直接进行编解码,这里Decode方法一定要传指针类型,Encode方法比较任意,指针or值类型都可以,gob支持的数据类型有限,struct、slice、map这些都支持,channel和func类型不支持。编解码双方要保持“数据一致性”,比如一个struct,双方相同的的字段其类型必须一致,缺失的字段将会直接被忽略,这里还要注意字段小写是不会被gob处理的,另外还要注意一点:gob操作的数据类型包含interface{}时,必须对interface{}所表示的实际类型进行一次register方可,以下是编解码的一个应用:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//将缓存数据写入io.Writer中
func (c *Cache) Save(w io.Writer) (err error) {
    enc := gob.NewEncoder(w)
    defer func() {
        if x := recover(); x != nil {
            err = fmt.Errorf("Error Registering item types with gob library")
        }
    }()
    c.mu.RLock()
    defer c.mu.RUnlock()
    for _, v := range c.items {
        gob.Register(v.Object)
    }
    err = enc.Encode(&c.items)
    return
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//从io.Reader读取
func (c *Cache) Load(r io.Reader) error {
    dec := gob.NewDecoder(r)
    items := make(map[string]Item, 0)
    err := dec.Decode(&items)
    if err != nil {
        return err
    }
    c.mu.Lock()
    defer c.mu.Unlock()
    for k, v := range items {
        obj, ok := c.items[k]
        if !ok || obj.IsExpired() {
            c.items[k] = v
        }
    }
    return nil
}

5、测试

其实整体实现就是对Cache struct的crud操作,就不多记录了,测试下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
package main
 
import (
    "cache"
    "fmt"
    "time"
)
 
func main() {
    defaultExpiration, _ := time.ParseDuration("0.5h")
    gcInterval, _ := time.ParseDuration("3s")
    c := cache.NewCache(defaultExpiration, gcInterval)
 
    expiration, _ := time.ParseDuration("2s")
    k1 := "hello world!"
    c.Set("k1", k1, expiration)
 
    if v, found := c.Get("k1"); found {
        fmt.Println("found k1:", v)
    } else {
        fmt.Println("not found k1")
    }
 
    err := c.SaveToFile("./items.txt")
    if err != nil {
        fmt.Println(err)
    }
    err = c.LoadFromFile("./items.txt")
    if err != nil {
        fmt.Println(err)
    }
 
    s, _ := time.ParseDuration("4s")
    time.Sleep(s)
    if v, found := c.Get("k1"); found {
        fmt.Println("found k1:", v)
    } else {
        fmt.Println("not found k1")
    }
 
}

输出结果如下:

image

这里对k1设置2s的过期时间,time.Sleep等待4s之后再去获取缓存的k1数据,这时已经为空。

至此,over。。。

Go 语言编写的缓存及缓存过滤库:groupcache

groupcache 是使用 Go 语言编写的缓存及缓存过滤库,作为 memcached 许多场景下的替代版本。 对比原始 memcached         首先,groupcache 与 ...

golang的一个基于内存的key-value 缓存

golang key-value memcache

大龄程序员的发展方向是做管理还是继续写程序

据观察,大龄程序员的出路无非是三条:做管理、自己创业和继续写程序。 今天我们只讨论做管理和继续写程序 大龄程序猿,顾名思义,就是年纪大了或者做的时间比较长的程序员。为什么会有这样的讨论,但凡在工作岗位...
  • DJY1992
  • DJY1992
  • 2016年12月15日 12:11
  • 11687

beego网站开发 定时执行任务

上网查了下相关资料,基本上都介绍的是github.com\robfig\cron这个包来执行定时任务,试了下确实可以执行。但是此包下没有删除任务的方法,只有暂停的方法(Stop),若要停止之前的任务只...

Golang web 开发实战之 session 缓存:如何使用 redigo 将一个结构体数据保存到 redis?

自定义 session 结构体:type Session struct { SessionID string `json:"sessionId" bson:"sessionId"` ...
  • defonds
  • defonds
  • 2016年07月21日 17:11
  • 5630

通过内存缓存来提升计算性能(golang代码)

当在进行大量的计算时,提升性能最直接有效的一种方式就是避免重复计算。通过在内存中缓存和重复利用相同计算的结果,称之为内存缓存。        最明显的例子就是生成斐波那契数列的程序,要计算数列中第 ...
  • Benert
  • Benert
  • 2017年08月02日 20:15
  • 263

golang版的高效日志组件

package log import ( "sync" "time" "os" "fmt" "strconv" ) type Tlog struct{ Qidx in...
  • truexf
  • truexf
  • 2016年01月08日 17:43
  • 1059

golang基础-tailf日志组件使用

git上log日志组件 https://github.com/hpcloud/tail/blob/master/tail.go我们写个test来测试下这个组件package mainimport (...

Golang 并发非阻塞缓存

《The Go Programming Language》笔记import "sync"type Func func(key string) (interface{}, error)type resu...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:golang开发缓存组件
举报原因:
原因补充:

(最多只允许输入30个字)