高性能之对象池技术应用

原创董再东百胜技术团队

”在当前数字化时代，用户对在线服务的需求不断增加。为了满足实时性、稳定性的要求，构建高并发和高性能服务变得至关重要”

一、前言

在饮食行业的点餐APP中，顾客可以根据自己的需求选择附近的餐厅进入菜单进行点餐。从菜单的特性来看，其与访问量密切相关，即每个顾客在选择完成餐厅后，都会看到该餐厅对应的菜单数据，浏览人数越多，菜单的访问压力也就越大。而每个餐厅的菜单数据由特定于餐厅的差异数据和共性数据组成，在传统的菜单服务实现方法中，每当顾客选择餐厅进入菜单时，后端服务会根据菜单的共性数据来创建一个新对象。该方法的最大缺点就是：随着用户流量的增加，需要频繁地创建和销毁对象，导致后端服务在内存管理和性能方面效率低下。

本文将围绕此背景对对象池原理与对象池如何优化菜单业务进行详细介绍。

二、介绍

2.1 什么是对象池

即提前初始化一定数量实例的集合。当程序需要创建对象时从池子里获取，如果池子中没有符合条件的对象，则创建新的对象，使用完后需要进行回收，重新放入对象池，避免频繁创建对象造成内存开销，同时要建立清理机制，防止对象池无限增大。

2.2 实现方式

对象池的实现方式有很多种如：数组、链表等，但大多都千篇一律，本文将介绍golang的sync.pool底层原理来加深对对象池理解。

2.2.1 底层数据结构

数据结构源代码如下：

Gotype poolChain struct {    // head is the poolDequeue to push to. This is only accessed    // by the producer, so doesn't need to be synchronized.    head *poolChainElt
    // tail is the poolDequeue to popTail from. This is accessed    // by consumers, so reads and writes must be atomic.    tail *poolChainElt}
type poolChainElt struct {    poolDequeue
    // next and prev link to the adjacent poolChainElts in this    // poolChain.    //    // next is written atomically by the producer and read    // atomically by the consumer. It only transitions from nil to    // non-nil.    //    // prev is written atomically by the consumer and read    // atomically by the producer. It only transitions from    // non-nil to nil.    next, prev *poolChainElt}

type poolDequeue struct {    // headTail packs together a 32-bit head index and a 32-bit    // tail index. Both are indexes into vals modulo len(vals)-1.    //    // tail = index of oldest data in queue    // head = index of next slot to fill    //    // Slots in the range [tail, head) are owned by consumers.    // A consumer continues to own a slot outside this range until    // it nils the slot, at which point ownership passes to the    // producer.    //    // The head index is stored in the most-significant bits so    // that we can atomically add to it and the overflow is    // harmless.    headTail uint64
    // vals is a ring buffer of interface{} values stored in this    // dequeue. The size of this must be a power of 2.    //    // vals[i].typ is nil if the slot is empty and non-nil    // otherwise. A slot is still in use until *both* the tail    // index has moved beyond it and typ has been set to nil. This    // is set to nil atomically by the consumer and read    // atomically by the producer.    vals []eface}

sync.pool核心对象为poolChain，是一个链表 + ringBuffer(环形缓冲器) 结构：

2.2.2 结构优点

1. ringBuffer的使用：

• 无锁即可保证数据正确性

环形缓冲区通常有一个读指针和一个写指针。读指针指向环形缓冲区中可读的数据，写指针指向环形缓冲区中可写的缓冲区。通过移动读指针和写指针就可以实现缓冲区的数据读取和写入。在通常情况下，环形缓冲区的读用户仅仅会影响读指针，而写用户仅仅会影响写指针

• 预先分配好内存，且分配的内存项可不断复用

• 连续内存结构，非常利于CPU Cache，访问速度快

cpu读取数据时会将数据从内存加载到自身三级缓存，Linux CPU Cache结构如下：

数据从内存中读取是以⼀小块⼀小块读取数据的，⽽不是按照单个元素来读取数据的，在 CPU Cache 中的，这样⼀小块⼀小块的数据，称为 Cache Line（缓存块）。所以连续内存数据会被cache line命中一起加载到CPU缓存中，减少了数据加载次数。

2. lock free的使用：

poolDequeue结构的head和tail是一个uint64的headTail变量。这是因为headTail 变量将 head和tail组在一起：其中高32位是head 变量，低32位是tail 变量。如下图所示：

在golang中poolDequeue可能会被多个P同时访问(GMP)，在不引入 Mutex 锁的前提下，sync.Pool 利用了 atomic（原子锁）包中的 CAS 操作。两个 P 都可能会拿到对象，但在最终设置 headTail 的时候，只会有一个 P 调用 CAS 成功，另外一个 CAS 失败。

Goatomic.CompareAndSwapUint64(&d.headTail, ptrs, ptrs2)

在更新 head 和 tail 的时候，也是通过原子变量 + 位运算进行操作的。例如，当实现 head++ 的时候，需要通过以下代码实现：

Goconst dequeueBits = 32atomic.AddUint64(&d.headTail, 1<<dequeueBits)

以上就是sync.pool底层对象池得基本原理，如想要更深入了解可自行研读golang sync.pool源码。

2.3 Benchmark性能测试演示

本文使用golang的sync.pool框架进行事例演示,完整代码如下：

Gopackage tmp
import (    "sync"    "testing"    "time")
var pool = sync.Pool{    New: func() interface{} {        return new(YumcInfo)    },}
// 模拟大对象type NInfo struct {    name    string    local   string    content string}
func (y *NInfo) init() {    y.name = ""    y.local = ""    y.content = ""}
func newNObj() *NInfo {    //耗时模拟    time.Sleep(100 * time.Millisecond)    return new(NInfo)}
// 不使用poolfunc BenchmarkWrite(b *testing.B) {    var p *NInfo    for n := 0; n < b.N; n++ {    //验证耗时性能，这层循环需要注释        for j := 0; j < 20000; j++ {            p = newNObj()            p.name = "旅游景区"            p.local = "南京市区"            p.content = "夫子庙、紫荆山、钟山陵"        }    }}
// 使用poolfunc BenchmarkWriteWithPool(b *testing.B) {    for n := 0; n < b.N; n++ {        for j := 0; j < 20000; j++ {            p := pool.Get().(*NInfo) // 如果是第一个调用，则创建一个缓冲区            p.name = "旅游景区"            p.local = "南京市区"            p.content = "夫子庙、紫荆山、钟山陵"
            // 放回 sync.Pool中,需要重置对象内容            p.init()            pool.Put(p)        }    }}