382 lines
19 KiB
Markdown
382 lines
19 KiB
Markdown
|
||
|
||
因收到Google相关通知，网站将会择期关闭。相关通知内容
|
||
|
||
|
||
17 业务脚本：为什么说可编程订阅式缓存服务更有用？
|
||
你好，我是徐长龙。
|
||
|
||
我们已经习惯了使用缓存集群对数据做缓存，但是这种常见的内存缓存服务有很多不方便的地方，比如集群会独占大量的内存、不能原子修改缓存的某一个字段、多次通讯有网络损耗。
|
||
|
||
很多时候我们获取数据并不需要全部字段，但因为缓存不支持筛选，批量获取数据的场景下性能就会下降很多。这些问题在读多写多的场景下，会更加明显。
|
||
|
||
有什么方式能够解决这些问题呢？这节课，我就带你了解另外一种有趣的数据缓存方式——可编程订阅式缓存服务。学完今天的内容，相信你会对缓存服务如何做产生新的思考。
|
||
|
||
缓存即服务
|
||
|
||
可编程订阅式缓存服务的意思是，我们可以自行实现一个数据缓存服务直接提供给业务服务使用，这种实现能够根据业务的需要，主动缓存数据并提供一些数据整理和计算的服务。
|
||
|
||
自实现的数据缓存服务虽然繁琐，但同时也有很多优势，除去吞吐能力的提升，我们还可以实现更多有趣的定制功能，还有更好的计算能力，甚至可以让我们的缓存直接对外提供基础数据的查询服务。
|
||
|
||
|
||
|
||
上图是一个自实现的缓存功能结构，可以说这种缓存的性能和效果更好，这是因为它对数据的处理方式跟传统模式不同。
|
||
|
||
传统模式下，缓存服务不会对数据做任何加工，保存的是系列化的字符串，大部分的数据无法直接修改。当我们使用这种缓存对外进行服务时，业务服务需要将所有数据取出到本地内存，然后进行遍历加工方可使用。
|
||
|
||
而可编程缓存可以把数据结构化地存在map中，相比传统模式序列化的字符串，更节省内存。
|
||
|
||
更方便的是，我们的服务无需再从其他服务取数据来做计算，这样会节省大量网络交互耗时，适合用在实时要求极高的场景里。如果我们的热数据量很大，可以结合RocksDB等嵌入式引擎，用有限的内存提供大量数据的服务。
|
||
|
||
除了常规的数据缓存服务外，可编程缓存还支持缓存数据的筛选过滤、统计计算、查询、分片、数据拼合。关于查询服务,我补充说明一下，对外的服务建议通过类似Redis的简单文本协议提供服务，这样会比HTTP协议性能会更好。
|
||
|
||
Lua脚本引擎
|
||
|
||
虽然缓存提供业务服务能提高业务灵活度，但是这种方式也有很多缺点，最大的缺点就是业务修改后，我们需要重启服务才能够更新我们的逻辑。由于内存中保存了大量的数据，重启一次数据就需要繁琐的预热，同步代价很大。
|
||
|
||
为此，我们需要给设计再次做个升级。这种情况下，lua脚本引擎是个不错的选择。lua是一个小巧的嵌入式脚本语言，通过它可以实现一个高性能、可热更新的脚本服务，从而和嵌入的服务高效灵活地互动。
|
||
|
||
我画了一张示意图，描述了如何通过lua脚本来具体实现可编程缓存服务：
|
||
|
||
|
||
|
||
如上图所示，可以看到我们提供了Kafka消费、周期任务管理、内存缓存、多种数据格式支持、多种数据驱动适配这些服务。不仅仅如此，为了减少由于逻辑变更导致的服务经常重启的情况，我们还以性能损耗为代价，在缓存服务里嵌入了lua脚本引擎，借此实现动态更新业务的逻辑。
|
||
|
||
lua引擎使用起来很方便，我们结合后面这个实现例子看一看，这是一个Go语言写的嵌入lua实现，代码如下所示：
|
||
|
||
package main
|
||
|
||
import "github.com/yuin/gopher-lua"
|
||
|
||
// VarChange 用于被lua调用的函数
|
||
func VarChange(L *lua.LState) int {
|
||
lv := L.ToInt(1) //获取调用函数的第一个参数，并且转成int
|
||
L.Push(lua.LNumber(lv * 2)) //将参数内容直接x2，并返回结果给lua
|
||
return 1 //返回结果参数个数
|
||
}
|
||
|
||
func main() {
|
||
L := lua.NewState() //新lua线程
|
||
defer L.Close() //程序执行完毕自动回收
|
||
|
||
// 注册lua脚本可调用函数
|
||
// 在lua内调用varChange函数会调用这里注册的Go函数 VarChange
|
||
L.SetGlobal("varChange", L.NewFunction(VarChange))
|
||
|
||
//直接加载lua脚本
|
||
//脚本内容为：
|
||
// print "hello world"
|
||
// print(varChange(20)) # lua中调用go声明的函数
|
||
if err := L.DoFile("hello.lua"); err != nil {
|
||
panic(err)
|
||
}
|
||
|
||
// 或者直接执行string内容
|
||
if err := L.DoString(`print("hello")`); err != nil {
|
||
panic(err)
|
||
}
|
||
}
|
||
|
||
// 执行后输出结果：
|
||
//hello world
|
||
//40
|
||
//hello
|
||
|
||
|
||
从这个例子里我们可以看出，lua引擎是可以直接执行lua脚本的，而lua脚本可以和Golang所有注册的函数相互调用，并且可以相互传递交换变量。
|
||
|
||
回想一下，我们做的是数据缓存服务，所以需要让lua能够获取修改服务内的缓存数据，那么，lua是如何和嵌入的语言交换数据的呢？我们来看看两者相互调用交换的例子：
|
||
|
||
package main
|
||
|
||
import (
|
||
"fmt"
|
||
"github.com/yuin/gopher-lua"
|
||
)
|
||
|
||
func main() {
|
||
L := lua.NewState()
|
||
defer L.Close()
|
||
//加载脚本
|
||
err := L.DoFile("vardouble.lua")
|
||
if err != nil {
|
||
panic(err)
|
||
}
|
||
// 调用lua脚本内函数
|
||
err = L.CallByParam(lua.P{
|
||
Fn: L.GetGlobal("varDouble"), //指定要调用的函数名
|
||
NRet: 1, // 指定返回值数量
|
||
Protect: true, // 错误返回error
|
||
}, lua.LNumber(15)) //支持多个参数
|
||
if err != nil {
|
||
panic(err)
|
||
}
|
||
//获取返回结果
|
||
ret := L.Get(-1)
|
||
//清理下，等待下次用
|
||
L.Pop(1)
|
||
|
||
//结果转下类型，方便输出
|
||
res, ok := ret.(lua.LNumber)
|
||
if !ok {
|
||
panic("unexpected result")
|
||
}
|
||
fmt.Println(res.String())
|
||
}
|
||
|
||
// 输出结果：
|
||
// 30
|
||
|
||
|
||
其中vardouble.lua内容为：
|
||
|
||
function varDouble(n)
|
||
return n * 2
|
||
end
|
||
|
||
|
||
通过这个方式，lua和Golang就可以相互交换数据和相互调用。对于这种缓存服务普遍要求性能很好，这时我们可以统一管理加载过lua的脚本及LState脚本对象的实例对象池，这样会更加方便，不用每调用一次lua就加载一次脚本，方便获取和使用多线程、多协程。
|
||
|
||
Lua脚本统一管理
|
||
|
||
通过前面的讲解我们可以发现，在实际使用时，lua会在内存中运行很多实例。为了更好管理并提高效率，我们最好用一个脚本管理系统来管理所有lua的实运行例子，以此实现脚本的统一更新、编译缓存、资源调度和控制单例。
|
||
|
||
lua脚本本身是单线程的，但是它十分轻量，一个实例大概是144kb的内存损耗，有些服务平时能跑成百上千个lua实例。
|
||
|
||
为了提高服务的并行处理能力，我们可以启动多协程，让每个协程独立运行一个lua线程。为此，gopher-lua库提供了一个类似线程池的实现，通过这个方式我们不需要频繁地创建、关闭lua，官方例子具体如下：
|
||
|
||
//保存lua的LState的池子
|
||
type lStatePool struct {
|
||
m sync.Mutex
|
||
saved []*lua.LState
|
||
}
|
||
// 获取一个LState
|
||
func (pl *lStatePool) Get() *lua.LState {
|
||
pl.m.Lock()
|
||
defer pl.m.Unlock()
|
||
n := len(pl.saved)
|
||
if n == 0 {
|
||
return pl.New()
|
||
}
|
||
x := pl.saved[n-1]
|
||
pl.saved = pl.saved[0 : n-1]
|
||
return x
|
||
}
|
||
|
||
//新建一个LState
|
||
func (pl *lStatePool) New() *lua.LState {
|
||
L := lua.NewState()
|
||
// setting the L up here.
|
||
// load scripts, set global variables, share channels, etc...
|
||
//在这里我们可以做一些初始化
|
||
return L
|
||
}
|
||
|
||
//把Lstate对象放回到池中，方便下次使用
|
||
func (pl *lStatePool) Put(L *lua.LState) {
|
||
pl.m.Lock()
|
||
defer pl.m.Unlock()
|
||
pl.saved = append(pl.saved, L)
|
||
}
|
||
|
||
//释放所有句柄
|
||
func (pl *lStatePool) Shutdown() {
|
||
for _, L := range pl.saved {
|
||
L.Close()
|
||
}
|
||
}
|
||
// Global LState pool
|
||
var luaPool = &lStatePool{
|
||
saved: make([]*lua.LState, 0, 4),
|
||
}
|
||
|
||
//协程内运行的任务
|
||
func MyWorker() {
|
||
//通过pool获取一个LState
|
||
L := luaPool.Get()
|
||
//任务执行完毕后，将LState放回pool
|
||
defer luaPool.Put(L)
|
||
// 这里可以用LState变量运行各种lua脚本任务
|
||
//例如 调用之前例子中的的varDouble函数
|
||
err = L.CallByParam(lua.P{
|
||
Fn: L.GetGlobal("varDouble"), //指定要调用的函数名
|
||
NRet: 1, // 指定返回值数量
|
||
Protect: true, // 错误返回error
|
||
}, lua.LNumber(15)) //这里支持多个参数
|
||
if err != nil {
|
||
panic(err) //仅供演示用，实际生产不推荐用panic
|
||
}
|
||
}
|
||
func main() {
|
||
defer luaPool.Shutdown()
|
||
go MyWorker() // 启动一个协程
|
||
go MyWorker() // 启动另外一个协程
|
||
/* etc... */
|
||
}
|
||
|
||
|
||
通过这个方式我们可以预先创建一批LState，让它们加载好所有需要的lua脚本，当我们执行lua脚本时直接调用它们，即可对外服务，提高我们的资源复用率。
|
||
|
||
变量的交互
|
||
|
||
事实上我们的数据既可以保存在lua内，也可以保存在Go中，通过相互调用来获取对方的数据。个人习惯将数据放在Go中封装，供lua调用，主要是因为这样相对规范、比较好管理，毕竟脚本会有损耗。
|
||
|
||
前面提到过，我们会将一些数据用struct和map组合起来，对外提供数据服务。那么lua和Golang如何交换struct一类数据呢？
|
||
|
||
这里我选择了官方提供的例子，但额外加上了大量注释，帮助你理解这个交互过程。
|
||
|
||
// go用于交换的 struct
|
||
type Person struct {
|
||
Name string
|
||
}
|
||
|
||
//为这个类型定义个类型名称
|
||
const luaPersonTypeName = "person"
|
||
|
||
// 在LState对象中，声明这种类型，这个只会在初始化LState时执行一次
|
||
// Registers my person type to given L.
|
||
func registerPersonType(L *lua.LState) {
|
||
//在LState中声明这个类型
|
||
mt := L.NewTypeMetatable(luaPersonTypeName)
|
||
//指定 person 对应 类型type 标识
|
||
//这样 person在lua内就像一个 类声明
|
||
L.SetGlobal("person", mt)
|
||
// static attributes
|
||
// 在lua中定义person的静态方法
|
||
// 这句声明后 lua中调用person.new即可调用go的newPerson方法
|
||
L.SetField(mt, "new", L.NewFunction(newPerson))
|
||
// person new后创建的实例，在lua中是table类型，你可以把table理解为lua内的对象
|
||
// 下面这句主要是给 table定义一组methods方法，可以在lua中调用
|
||
// personMethods是个map[string]LGFunction
|
||
// 用来告诉lua，method和go函数的对应关系
|
||
L.SetField(mt, "__index", L.SetFuncs(L.NewTable(), personMethods))
|
||
}
|
||
// person 实例对象的所有method
|
||
var personMethods = map[string]lua.LGFunction{
|
||
"name": personGetSetName,
|
||
}
|
||
// Constructor
|
||
// lua内调用person.new时，会触发这个go函数
|
||
func newPerson(L *lua.LState) int {
|
||
//初始化go struct 对象 并设置name为 1
|
||
person := &Person{L.CheckString(1)}
|
||
// 创建一个lua userdata对象用于传递数据
|
||
// 一般 userdata包装的都是go的struct，table是lua自己的对象
|
||
ud := L.NewUserData()
|
||
ud.Value = person //将 go struct 放入对象中
|
||
// 设置这个lua对象类型为 person type
|
||
L.SetMetatable(ud, L.GetTypeMetatable(luaPersonTypeName))
|
||
// 将创建对象返回给lua
|
||
L.Push(ud)
|
||
//告诉lua脚本，返回了数据个数
|
||
return 1
|
||
}
|
||
// Checks whether the first lua argument is a *LUserData
|
||
// with *Person and returns this *Person.
|
||
func checkPerson(L *lua.LState) *Person {
|
||
//检测第一个参数是否为其他语言传递的userdata
|
||
ud := L.CheckUserData(1)
|
||
// 检测是否转换成功
|
||
if v, ok := ud.Value.(*Person); ok {
|
||
return v
|
||
}
|
||
L.ArgError(1, "person expected")
|
||
return nil
|
||
}
|
||
// Getter and setter for the Person#Name
|
||
func personGetSetName(L *lua.LState) int {
|
||
// 检测第一个栈，如果就只有一个那么就只有修改值参数
|
||
p := checkPerson(L)
|
||
if L.GetTop() == 2 {
|
||
//如果栈里面是两个，那么第二个是修改值参数
|
||
p.Name = L.CheckString(2)
|
||
//代表什么数据不返回，只是修改数据
|
||
return 0
|
||
}
|
||
//如果只有一个在栈，那么是获取name值操作，返回结果
|
||
L.Push(lua.LString(p.Name))
|
||
|
||
//告诉会返回一个参数
|
||
return 1
|
||
}
|
||
func main() {
|
||
// 创建一个lua LState
|
||
L := lua.NewState()
|
||
defer L.Close()
|
||
|
||
//初始化 注册
|
||
registerPersonType(L)
|
||
// 执行lua脚本
|
||
if err := L.DoString(`
|
||
//创建person，并设置他的名字
|
||
p = person.new("Steven")
|
||
print(p:name()) -- "Steven"
|
||
//修改他的名字
|
||
p:name("Nico")
|
||
print(p:name()) -- "Nico"
|
||
`); err != nil {
|
||
panic(err)
|
||
}
|
||
}
|
||
|
||
|
||
可以看到，我们通过lua脚本引擎就能很方便地完成相互调用和交换数据，从而实现很多实用的功能，甚至可以用少量数据直接写成lua脚本的方式来加载服务。-
|
||
另外，gopher-lua还提供了模块功能，帮助我们更好地管理脚本和代码，有兴趣的话可以自行深入，参考资料在这里。
|
||
|
||
缓存预热与数据来源
|
||
|
||
了解了lua后，我们再看看服务如何加载数据。服务启动时，我们需要将数据缓存加载到缓存中，做缓存预热，待数据全部加载完毕后，再开放对外的API端口对外提供服务。
|
||
|
||
加载过程中如果用上了lua脚本，就可以在服务启动时对不同格式的数据做适配加工，这样做也能让数据来源更加丰富。
|
||
|
||
常见的数据来源是大数据挖掘周期生成的全量数据离线文件，通过NFS或HDFS挂载定期刷新、加载最新的文件。这个方式适合数据量大且更新缓慢的数据，缺点则是加载时需要整理数据，如果情况足够复杂，800M大小的数据要花1～10分钟方能加载完毕。
|
||
|
||
除了使用文件方式外，我们也可以在程序启动后扫数据表恢复数据，但这么做数据库要承受压力，建议使用专用的从库。但相对磁盘离线文件的方式，这种方式加载速度更慢。
|
||
|
||
上面两种方式加载都有些慢，我们还可以将 RocksDB 嵌入到进程中，这样做可以大幅度提高我们的数据存储容量，实现内存磁盘高性能读取和写入。不过代价就是相对会降低一些查询性能。
|
||
|
||
RocksDB的数据可以通过大数据生成RocksDB格式的数据库文件，拷贝给我们的服务直接加载。这种方式可以大大减少系统启动中整理、加载数据的时间，实现更多的数据查询。
|
||
|
||
另外，如果我们对于本地有关系数据查询需求，也可以嵌入 SQLite 引擎，通过这个引擎可以做各种关系数据查询，SQLite的数据的生成也可以通过工具提前生成，给我们服务直接使用。但你要注意这个数据库不要超过10w条数据，否则很可能导致服务卡顿。
|
||
|
||
最后，对于离线文件加载，最好做一个CheckSum一类的文件，用来在加载文件之前检查文件的完整性。由于我们使用的是网络磁盘，不太确定这个文件是否正在拷贝中，需要一些小技巧保证我们的数据完整性，最粗暴的方式就是每次拷贝完毕后生成一个同名的文件，内部记录一下它的CheckSum，方便我们加载前校验。
|
||
|
||
离线文件能够帮助我们快速实现多个节点的数据共享和统一，如果我们需要多个节点数据保持最终一致性，就需要通过离线+同步订阅方式来实现数据的同步。
|
||
|
||
订阅式数据同步及启动同步
|
||
|
||
那么，我们的数据是如何同步更新的呢？
|
||
|
||
正常情况下，我们的数据来源于多个基础数据服务。如果想实时同步数据的更改，我们一般会通过订阅binlog将变更信息同步到Kafka，再通过Kafka的分组消费来通知分布在不同集群中的缓存。
|
||
|
||
收到消息变更的服务会触发lua脚本，对数据进行同步更新。通过lua我们可以触发式同步更新其他相关缓存，比如用户购买一个商品，我们要同步刷新他的积分、订单和消息列表个数。
|
||
|
||
周期任务
|
||
|
||
提到任务管理，不得不提一下周期任务。周期任务一般用于刷新数据的统计，我们通过周期任务结合lua自定义逻辑脚本，就能实现定期统计，这给我们提供了更多的便利。
|
||
|
||
定期执行任务或延迟刷新的过程中，常见的方式是用时间轮来管理任务，用这个方式可以把定时任务做成事件触发，这样能轻松地管理内存中的待触发任务列表，从而并行多个周期任务，无需使用sleep循环方式不断查询。对时间轮感兴趣的话，你可以点击这里查看具体实现。
|
||
|
||
另外，前面提到我们的很多数据都是通过离线文件做批量更新的，如果是一小时更新一次，那么一小时内新更新的数据就需要同步。
|
||
|
||
一般要这样处理：在我们服务启动加载的离线文件时，保存离线文件生成的时间，通过这个时间来过滤数据更新队列中的消息，等到我们的队列任务进度追到当前时间附近时，再开启对外数据的服务。
|
||
|
||
总结
|
||
|
||
读多写多的服务中，实时交互类服务非常多，对数据的实时性要求也很高，用集中型缓存很难满足服务所需。为此，行业里多数会通过服务内存数据来提供实时交互服务，但这么做维护起来十分麻烦，重启后需要恢复数据。为了实现业务逻辑无重启的更新，行业里通常会使用内嵌脚本的热更新方案。
|
||
|
||
常见的通用脚本引擎是lua，这是一个十分流行且方便的脚本引擎，在行业中，很多知名游戏及服务都使用lua来实现高性能服务的定制化业务功能，比如Nginx、Redis等。
|
||
|
||
把lua和我们的定制化缓存服务结合起来，即可制作出很多强大的功能来应对不同的场景。由于lua十分节省内存，我们在进程中开启成千上万的lua小线程，甚至一个用户一个LState线程对客户端提供状态机一样的服务。
|
||
|
||
用上面的方法，再结合lua和静态语言交换数据相互调用，并配合上我们的任务管理以及各种数据驱动，就能完成一个几乎万能的缓存服务。推荐你在一些小项目中亲自实践一下，相信会让你从不同视角看待已经习惯的服务，这样会有更多收获。
|
||
|
||
思考题
|
||
|
||
如何让Go的协程访问一个LState保存的数据？
|
||
|
||
欢迎你在留言区与我交流讨论，我们下节课见！
|
||
|
||
|
||
|
||
|