分布式缓存原理及Go实现 - 第一章

第一章：基于HTTP的内存缓存服务

缓存的概念：缓存(cache),指访问速度比一般的随机访问存储器(RAM)快的一种告诉存储器。通常不像系统主存那样使用DRAM(动态存储器)技术，而是使用更昂贵但是更快的SRAM(静态存储器)技术。

存储是非易失的，而缓存是允许丢失的。

• RAM：随机存储器，也叫主存，可以快速的进行读写，但是断电后RAM不能保存数据。

• ROM：只读存储器，工作过程中只能读出，不能像RAM一样快速的改写，ROM所存数据稳定，断电后数据仍能保存。

缓存服务放在其他服务的前端，只有当客户端需要的数据不存在与缓存中时，才去访问实际的服务。目前业界使用较多的缓存服务有Memcached和Redis等。他们都是内存内缓存，单结点最大的容量不能超过整个系统的内存。

分布式缓存集群的好处：单结点的扩展性，性价比，容错率都低于分布式缓存集群。

数据持久化：通俗的讲就是瞬时数据(比如内存中的数据，不能永久保存)持久化为持久数据。

第一章：基于HTTP的内存缓存服务

1.1 缓存服务的接口

利用 HTTP/REST 协议的 GET/PUT/DELETE 方法实现缓存的 Get/Set/Del 基本操作

Set操作用于将一对键值对设置进缓存服务器，通过HTTP的Put方法进行。

Get操作用于查询某个键并获取其值，通过HTTP的Get方法进行。

Del操作用于在缓存中删除某个键，通过HTTP的Delete方法进行。

1.2 Go语言实现

目录结构:

server
- cache
  - cache.go
  - inmemory.go
  - new.go
  - stat.go
- http
  - cache.go
  - server.go
  - status.go
- main.go

1.2.1 main包实现

package main
//这是此目录下自己定义的两个包，cache包和http包
import (
	"./cache" 
	"./http"
)

func main() {
	c := cache.New("inmemory")
	http.New(c).Listen()
}

1.2.2 cache包实现

1. Cache接口实现

//首先定义了一个cache包接口：
package cache
type Cache interface { //声明了一个Cache接口
    Set(string, []byte) error   //Set方法将键值对写入缓存，接受两个参数，string是键的类型，[]byte是值的类型(unit8类型，代表了ASCII码的一个字符)，一个返回值，返回error类型
	Get(string) ([]byte, error) //Get方法通过键来获取Cache的信息，两个返回值分别是键对应的值和error
	Del(string) error           //Del方法通过键删除key，返回一个error类型
	GetStat() Stat              //获取缓存的状态，Stat是一个结构体
}

Go语言中，接口和声明是完全分开的，接口有其自己的类型interface，但是只定义接口是没用的，还需要实现接口。其中Stat的实现如下：

1. Stat结构体的实现

//Stat结构体的实现如下：
package cache

type Stat struct {
	Count     int64 //Count表示缓存目前保存的键值对数量
	KeySize   int64 //表示Key占据的总字节数
	ValueSize int64 //表示value占据的总字节数
}
//add和del方法用于新加键值对和删除键值对
func (s *Stat) add(k string, v []byte) {
	s.Count += 1
	s.KeySize += int64(len(k))
	s.ValueSize += int64(len(v))
}

func (s *Stat) del(k string, v []byte) {
	s.Count -= 1
	s.KeySize -= int64(len(k))
	s.ValueSize -= int64(len(v))
}

1. New函数实现

//New函数用于创建并返回一个Cache接口
package cache
import "log"
func New(typ string) Cache { //new函数创建并返回一个Cache接口
	var c Cache
	if typ == "inmemory" {
		c = newInMemoryCache()
	}
	if c == nil {
		panic("unknown cache type " + typ)
	}
	log.Println(typ, "ready to serve")
	return c
}

1. inMemoryCache实现

//这部分主要负责cache的set,get,del函数，以及获取缓存状态新建端口的函数的具体实现
package cache

import "sync"

type inMemoryCache struct {
	c     map[string][]byte //包含一个成员c，类型是string为键，byte为值的map，用来保存键值对
	mutex sync.RWMutex      //为map的并发访问提供锁保护
	Stat                    //记录缓存状态
}

//这种形式是Go语言中的方法，方法就是包含了接收者的函数，(接收者很可能就是一个结构或者类经过实例化的结果)
func (c *inMemoryCache) Set(k string, v []byte) error {
	c.mutex.Lock()         //定义了一个写锁
	defer c.mutex.Unlock() //defer语句在函数结束时被被调用
	tmp, exist := c.c[k]   //exist判断缓存中是否有这个键，如果有exist为true，tmp是缓存中这个键对应的值
	if exist {
		c.del(k, tmp) //如果缓存中有这个值，就把这个键值对删掉
	}
	c.c[k] = v  //c.c[k]代表取叫c的inMemoryCache结构体中的map类型的c，它的键的值是k，将v赋值给键对应的值
	c.add(k, v) //stat中定义，更新缓存
	return nil
}

func (c *inMemoryCache) Get(k string) ([]byte, error) {
	c.mutex.RLock() //定义了一个读锁
	defer c.mutex.RUnlock()
	return c.c[k], nil //通过键得到值，不用更新缓存
}

func (c *inMemoryCache) Del(k string) error {
	c.mutex.Lock()
	defer c.mutex.Unlock()
	v, exist := c.c[k] //exist判断缓存中是否有这个键，如果有exist为true，v是缓存中这个键对应的值
	if exist {
		delete(c.c, k) //从map中删除一组键值对
		c.del(k, v)    //更新缓存状态
	}
	return nil
}

func (c *inMemoryCache) GetStat() Stat { //记录缓存状态
	return c.Stat
}

func newInMemoryCache() *inMemoryCache {
	return &inMemoryCache{make(map[string][]byte), sync.RWMutex{}, Stat{}} //新建一个inMemoryCache，make可以用来初始化slice，map，chan
}

Go语言的map支持多个goroutine同时读，但不支持多个goroutine同时写或者同时既读又写

相关的概念可以参考：

高并发架构系列：什么是分布式锁？Redis实现分布式锁详解 - 哔哩哔哩 (bilibili.com)

并发与并行的区别是什么？ - 知乎 (zhihu.com)

扩展内容：Go语言的互斥锁和读写锁：

Go 互斥锁（sync.Mutex）和 读写锁（sync.RWMutex） - kaichenkai - 博客园 (cnblogs.com)

什么时候需要用到锁？

当程序中就一个线程的时候，是不需要加锁的，但是通常实际的代码不会只是单线程，所以这个时候就需要用到锁了，那么关于锁的使用场景主要涉及到哪些呢？

• 多个线程在读相同的数据时
• 多个线程在写相同的数据时

• 同一个资源，有读又有写

  互斥锁：互斥锁是一种常用的控制共享资源访问的方法，它能够保证同时只有一个 goroutine 可以访问到共享资源（同一个时刻只有一个线程能够拿到锁）

在读多写少的环境中，可以优先使用读写锁（sync.RWMutex），它比互斥锁更加高效。sync 包中的 RWMutex 提供了读写互斥锁的封装

读写锁分为：读锁和写锁

• 如果设置了一个写锁，那么其它读的线程以及写的线程都拿不到锁，这个时候，与互斥锁的功能相同
• 如果设置了一个读锁，那么其它写的线程是拿不到锁的，但是其它读的线程是可以拿到锁

上面的inMemoryCache的例子用到了读写锁，也证明的了Go语言的map支持多个goroutine同时读，但是不支持多个goroutine同时写或者既读又写。

1.2.3 HTTP包的实现

1. Server相关实现

package http

import (
	"../cache"
	"net/http"	//这个包是Go语言库中的包，不是自己定义的包
)

type Server struct {
	cache.Cache //前面定义的cache接口
}

func (s *Server) Listen() {
	http.Handle("/cache/", s.cacheHandler())  //返回一个http.Handler接口，用来处理cache的请求
	http.Handle("/status", s.statusHandler()) //返回一个http.Handler接口，用来处理状态的请求
	http.ListenAndServe(":12345", nil)
}

func New(c cache.Cache) *Server { //新建一个Server
	return &Server{c}
}

1. cacheHandler的实现

package http

import (
	"io/ioutil"
	"log"
	"net/http"
	"strings"
)

type cacheHandler struct {
	*Server
}

func (h *cacheHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { //客户端向内存发出Request(r)，内存向客户端发除Response(w)
	key := strings.Split(r.URL.EscapedPath(), "/")[2]
	if len(key) == 0 {
		w.WriteHeader(http.StatusBadRequest)
		return
	}
	m := r.Method //m是客户端的请求方式
	if m == http.MethodPut {
		b, _ := ioutil.ReadAll(r.Body)
		if len(b) != 0 {
			e := h.Set(key, b)
			if e != nil {
				log.Println(e)
				w.WriteHeader(http.StatusInternalServerError)
			}
		}
		return
	}
	if m == http.MethodGet {
		b, e := h.Get(key)
		if e != nil {
			log.Println(e)
			w.WriteHeader(http.StatusInternalServerError)
			return
		}
		if len(b) == 0 {
			w.WriteHeader(http.StatusNotFound)
			return
		}
		w.Write(b)
		return
	}
	if m == http.MethodDelete {
		e := h.Del(key)
		if e != nil {
			log.Println(e)
			w.WriteHeader(http.StatusInternalServerError)
		}
		return
	}
	w.WriteHeader(http.StatusMethodNotAllowed)
}

func (s *Server) cacheHandler() http.Handler {
	return &cacheHandler{s}
}

Go标准包中net/http的Handler接口定义如下：

type Handler interface{
	ServeHTTP(ResponseWriter, *Request)
}

ServeHTTP方法解析URL获得key，并根据HTTP请求决定调用Cache.cache的哪种方法。这里用到了Go语言的多重内嵌；cacheHandler内嵌了Server结构体指针，Server内嵌了cache.Cache接口，于是cacheHandler就能直接访问cache.Cache的方法了。

3.statusHandler的实现

package http

import (
	"encoding/json"
	"log"
	"net/http"
)

type statusHandler struct {
	*Server
}

func (h *statusHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		w.WriteHeader(http.StatusMethodNotAllowed)
		return
	}
	b, e := json.Marshal(h.GetStat()) //调用Cache中的GetStat方法将返回的cache.Stat结构体用JSON编码后
	if e != nil {
		log.Println(e)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}
	w.Write(b) //写入HTTP的相应正文
}

func (s *Server) statusHandler() http.Handler {
	return &statusHandler{s}
}

1.3 功能测试

首先通过go mod init go-implement-your-cache-server-master可以将项目文件夹设置为路径文件，这样在go-implement-your-cache-server-master中会生成一个go.mod文件。

注意在vscode中使用文件的相对路径会有报错，将路径改为相对于go-implement-your-cache-server-master的路径，如"go-implement-your-cache-server-master/chapter1/server/cache"

实验结果：

可以看到实现了从客户端到内存的增删查操作。

1.4 与Redis比较

1.4.1 Redis介绍

数据持久化：通俗的讲就是瞬时数据(比如内存中的数据，不能永久保存)持久化为持久数据。

Redis的两种磁盘持久化方案：RDB (Redis Database) 和 AOF (Append Only File)；

RDB的持久化原理：会在特定的时间将内存的数据进行快照然后存入磁盘。当RDB开始工作时，Redis服务会将自己分叉出一个持久化进程，持久化进程负责写入磁盘。S此时原服务进程的一切内存数据相当于被保存了一份快照，持久化进程和原服务进程共享同一批虚拟内存页。但是如果这段时间有Set操作，就意味着原服务内存有一部分需要修改，这时候虚拟内存页会进行一个写时复制的操作，确保持久化进程的数据不被更新。

AOF的持久化原理：将服务端接到的所有写操作(Set 和 Del)计入磁盘的日志文件，重新开机时，Redis会重放日志文件来重新构建整个内存映像。

RDB和AOF相比性能更好，占用的磁盘更少，对Redis的性能影响更小，速度更快；但是在上次持久化到关机这段时间可能丢失数据，AOF可以保存到上次写数据。

1.4.2 redis-benchmark介绍

redis-benchmark是Redis服务自带的性能测试工具。

下载和安装参考：windows下安装Redis并部署成服务 - 丁国丰 - 博客园 (cnblogs.com)

Releases · microsoftarchive/redis (github.com)

在上面的地址下载并解压安装包

./redis-server启动Redis然后通过redis-benchmark -c 1 -n 100000 -d 1000 -t set,get -r 100000检测redis的性能如下：

go get命令：一键获取代码、编译并安装(因为网络的原因，这个过程经常会失败)

1.4.3 cache-benchmark介绍

cache-benchmark用来测试我们自己的cache的性能

go build会执行源码，并输出可执行文件

注意在检测性能时必须先启动1.2中提到的./server，这样cache-benchmark才能找到本机的缓存服务，这样就可以检测自己的缓存的性能了。