Go 并发编程 — 深入浅出 sync.Pool,最全的使用姿势,最深刻的原理

概要

Go 并发相关库 sync 里面有一个有趣的 package Pool,sync.Pool 是个有趣的库,用很少的代码实现了很巧的功能。第一眼看到 Pool 这个名字,就让人想到池子,元素池化是常用的性能优化的手段(性能优化的几把斧头:并发,预处理,缓存)。比如,创建一个 100 个元素的池,然后就可以在池子里面直接获取到元素,免去了申请和初始化的流程,大大提高了性能。释放元素也是直接丢回池子而免去了真正释放元素带来的开销。

但是再仔细一看 sync.Pool 的实现,发现比我预期的还更有趣。sync.Pool 除了最常见的池化提升性能的思路,最重要的是减少 GC 。常用于一些对象实例创建昂贵的场景。注意,Pool 是 Goroutine 并发安全的

初始化 Pool 实例 New

第一个步骤就是创建一个 Pool 实例,关键一点是配置 New 方法,声明 Pool 元素创建的方法。

bufferpool := &sync.Pool {
    New: func() interface {} {
        println("Create new instance")
        return struct{}{}
    }
}

申请对象 Get

buffer := bufferPool.Get()
Get 方法会返回 Pool 已经存在的对象,如果没有,那么就走慢路径,也就是调用初始化的时候定义的 New 方法(也就是最开始定义的初始化行为)来初始化一个对象。

释放对象 Put

bufferPool.Put(buffer)
使用对象之后,调用 Put 方法声明把对象放回池子。注意了,这个调用之后仅仅是把这个对象放回池子,池子里面的对象啥时候真正释放外界是不清楚的,是不受外部控制的

你看,Pool 的用户使用界面就这三个接口,非常简单,而且是通用型的 Pool 池模式,针对所有的对象类型都可以用。

为什么用 Pool,而不是在运行的时候直接实例化对象呢?

本质原因:Go 的内存释放是由 runtime 来自动处理的,有 GC 过程。

举个栗子

package main

import (
    "fmt"
    "sync"
    "sync/atomic"
)

// 用来统计实例真正创建的次数
var numCalcsCreated int32

// 创建实例的函数
func createBuffer() interface{} {
    // 这里要注意下,非常重要的一点。这里必须使用原子加,不然有并发问题;
    atomic.AddInt32(&numCalcsCreated, 1)
    buffer := make([]byte, 1024)
    return &buffer
}

func main() {
    // 创建实例
    bufferPool := &sync.Pool{
        New: createBuffer,
    }

    // 多 goroutine 并发测试
    numWorkers := 1024 * 1024
    var wg sync.WaitGroup
    wg.Add(numWorkers)

    for i := 0; i < numWorkers; i++ {
        go func() {
            defer wg.Done()
            // 申请一个 buffer 实例
            buffer := bufferPool.Get()
            _ = buffer.(*[]byte)
            // 释放一个 buffer 实例
            defer bufferPool.Put(buffer)
        }()
    }
    wg.Wait()
    fmt.Printf("%d buffer objects were created.\n", numCalcsCreated)
}

上面的例子可以直接复制运行起来看下,控制台输出:

➜  pool# go run test_pool.go        
3 buffer objects were created.
➜  pool# go run test_pool.go
4 buffer objects were created.

程序 go run 运行了两次,一次结果是 3 ,一次是 4 。这个是什么原因呢?

首先,这个是正常的情况,不知道你有没有注意到,创建 Pool 实例的时候,只要求填充了 New 函数,而根本没有声明或者限制这个 Pool 的大小。所以,记住一点程序员作为使用方不能对 Pool 里面的元素个数做假定

再来,如果我不用 Pool 来申请实例,而是直接申请,也就是上面的代码只改一行:

将以下代码:

// 申请一个 buffer 实例
buffer := bufferPool.Get()

修改成:

// 申请一个 buffer 实例
buffer := createBuffer()

这个时候,我们再执行程序 go run test_pool.go,会发现什么?

➜  pool go run test_pool_1.go
1048576 buffer objects were created.
➜  pool go run test_pool_1.go
1048576 buffer objects were created.

注意到,和之前有两个不同点

  1. 同样也是运行两次,两次结果相同。
  2. 对象创建的数量和并发 Worker 数量相同,数量等于 1048576 (这个就是 1024*1024);

原因很简单,因为每次都是直接调用 createBuffer 函数申请 buffer,有 1048576 个并发 Worker 调用,所以跑多少次结果都会是 1048576。

实际上还有一个不同点,就是程序跑的过程中,该进程分配消耗的内存很大。因为 Go 申请内存是程序员触发的,回收却是 Go 内部 runtime GC 回收器来执行的,这是一个异步的操作。这种业务不负责任的内存使用会对 GC 带来非常大的负担,进而影响整体程序的性能。

类比现实的例子

一个程序猿喝奶茶,需要一个吸管(吸管类比就是我们代码里的 buffer 对象喽),奶茶喝完吸管就扔了,那就是塑料垃圾了( Garbage )。清洁工老李( GC 回收器 )需要紧跟在后面打扫卫生,现在 1048576 个程序猿同时喝奶茶,每个人都现场要一根新吸管,喝完就扔,马上地上有 1048576 个塑料吸管垃圾。清洁工老李估计要累个半死。

那如果,现在在某个隐秘的角落放一个回收箱 ( 类比成 sync.Pool ) ,程序员喝完奶茶之后,吸管就丢到回收箱里,下一个程序员要用吸管的话,伸手进箱子摸一下,看下有管子吗?有的话,就拿来用了。没有的话,就再找人要一根新吸管。这样新吸管的使用数量就大大减少了呀,地上也没垃圾了,老李也轻松了,多好呀。

并且,极限情况下,如果大家喝奶茶足够快,保证箱子里每时每刻都至少有一根用过的吸管,那 1048576 个程序员估计用一根吸管都够了。。。。(有点想吐。。。)

回归正题

这就也解释了,为什么使用 sync.Pool 之后数量只有 3,4 个。但是进一步思考:为什么 sync.Pool 的两次使用结果输出不不一样呢?

因为复用的速度不一样。我们不能对 Pool 池里的 cache 的元素个数做任何假设。不过还是那句话,如果速度足够快,其实里面可以只有一个元素就可以服务 1048576 个并发的 Goroutine 。

sync.Pool 是并发安全的吗?

sync.Pool 当然是并发安全的。官方文档里明确说了:

A Pool is safe for use by multiple goroutines simultaneously.

但是,为什么我这里会单独提出来呢?

因为 sync.Pool 只是本身的 Pool 数据结构是并发安全的,并不是说 Pool.New 函数一定是线程安全的。Pool.New 函数可能会被并发调用 ,如果 New 函数里面的实现是非并发安全的,那就会有问题。

细心的小伙伴会注意到我在上面的代码例子里,关于 createBuffer 函数的实现里,对于 numCalcsCreated 的计数加是用原子操作的:atomic.AddInt32(&numCalcsCreated, 1) 。

func createBuffer() interface{} {
 // 这里要注意下,非常重要的一点。这里必须使用原子加,不然有并发问题;
 atomic.AddInt32(&numCalcsCreated, 1)
 buffer := make([]byte, 1024)
 return &buffer
}

因为 numCalcsCreated 是个全局变量,Pool.New( 也就是 createBuffer ) 并发调用的时候,会导致 data race ,所以只有用原子操作才能保证数据的正确性。

小伙伴们可以尝试下,把 atomic.AddInt32(&numCalcsCreated, 1) 这样代码改成 numCalcsCreated++ ,然后用 go run -race test_pool.go 命令检查一下,肯定会报告告警的,类似如下:

WARNING: DATA RACE
Read at 0x000001287538 by goroutine 10:

Previous write at 0x000001287538 by goroutine 7:

==================
==================
WARNING: DATA RACE
Read at 0x000001287538 by goroutine 9:
main.createBuffer()

本质原因:Pool.New 函数可能会被并发调用。

为什么 sync.Pool 不适合用于像 socket 长连接或数据库连接池?

因为,我们不能对 sync.Pool 中保存的元素做任何假设,以下事情是都可以发生的:

  1. Pool 池里的元素随时可能释放掉,释放策略完全由 runtime 内部管理;
  2. Get 获取到的元素对象可能是刚创建的,也可能是之前创建好 cache 住的。使用者无法区分;
  3. Pool 池里面的元素个数你无法知道;

所以,只有的你的场景满足以上的假定,才能正确的使用 Pool 。sync.Pool 本质用途是增加临时对象的重用率,减少 GC 负担。划重点:临时对象。所以说,像 socket 这种带状态的,长期有效的资源是不适合 Pool 的。

总结

  1. sync.Pool 本质用途是增加临时对象的重用率,减少 GC 负担;
  2. 不能对 Pool.Get 出来的对象做预判,有可能是新的(新分配的),有可能是旧的(之前人用过,然后 Put 进去的);
  3. 不能对 Pool 池里的元素个数做假定,你不能够;
  4. sync.Pool 本身的 Get, Put 调用是并发安全的,sync.New 指向的初始化函数会并发调用,里面安不安全只有自己知道;
  5. 当用完一个从 Pool 取出的实例时候,一定要记得调用 Put,否则 Pool 无法复用这个实例,通常这个用 defer 完成;
  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
### 回答1: 《深入浅出Node.js》是朴灵所著的一本关于Node.js的入门指南。这本书是为那些对Node.js有兴趣的开发者准备的,无论他们是初学者还是有一定经验的开发者。 朴灵通过本书详细介绍了Node.js的基本概念、原理使用方法。他首先解释了Node.js的诞生背景和发展历程,然后深入讲解了其核心模块和API,如文件操作、网络编程、子进程等。此外,朴灵还介绍了如何使用Node.js来构建Web应用程序和开发高性能的服务器,包括使用Express框架、连接数据库和处理并发请求等。 这本书的特点之一是朴灵通过大量的实例来说明概念和技术。他用简单的语言和清晰的代码片段解释了复杂的概念和技术,使读者能够更好地理解和掌握Node.js的核心思想和用法。此外,朴灵还提供了一些实际项目的示例,让读者能够将所学知识应用到实际开发中。 总的来说,《深入浅出Node.js》是一本非常适合初学者的入门指南。朴灵通过简洁明了的语言和丰富的实例,帮助读者系统地学习和理解Node.js的基本概念和使用方法。无论是想深入了解Node.js的原理和实现,还是想利用Node.js构建高性能的Web应用程序,读者都能从本书中获得有价值的知识和经验。 ### 回答2: 《深入浅出nodejs》是朴灵所著的一本关于Node.js的入门级编程书籍。Node.js是一种基于Chrome V8引擎的JavaScript运行环境,可以用于构建高性能的网络应用程序。这本书以深入浅出的方式解释了Node.js的核心原理和基本用法。 首先,书中介绍了Node.js的基本概念和特点。它强调了Node.js的事件驱动、非阻塞I/O模型以及单线程的特性,这些特点使得Node.js非常适合处理高并发的网络应用。读者通过理解这些概念,可以更好地理解Node.js的设计思想和运行机制。 接着,书中详细介绍了Node.js的模块系统。Node.js的模块系统是一个核心特性,它使得代码的复用和模块化变得非常简单。在书中,读者将学习如何编写自己的模块,如何引入和使用第三方模块。 此外,书中还涵盖了Node.js的常用库和框架。例子包括了Express框架、Socket.IO库等等。读者将学习如何使用这些库和框架来构建具有实际功能的网络应用。 最后,书中还对Node.js的部署和性能优化进行了介绍。Node.js的部署可以包括单机部署和集群部署,读者将学习如何选择最适合自己应用的部署方式。性能优化方面,书中详细介绍了Node.js的性能瓶颈和优化方法,帮助读者进一步提升自己应用的性能。 总之,《深入浅出nodejs》这本书以通俗易懂的方式介绍了Node.js的核心概念和基本用法,适合初学者入门。通过阅读这本书,读者可以快速了解和掌握Node.js的基本知识,为进一步深入学习和应用打下基础。 ### 回答3: 《深入浅出Node.js》是朴灵所著的一本介绍Node.js的书籍。Node.js是一种基于Chrome V8引擎构建的JavaScript运行环境,能够使JavaScript在服务器端运行。这本书将帮助读者深入了解Node.js的原理、应用场景和开发技巧。 首先,本书从Node.js的基础入手,介绍了Node.js的产生背景、优势和应用场景。然后,书中详细讲解了Node.js的事件驱动、非阻塞I/O等核心机制,以及如何使用JavaScript进行模块化开发和编写高效的异步代码。此外,书中还涵盖了常用的Node.js模块、网络编程、Web开发、数据存储和安全等方面的内容。 朴灵以通俗易懂的语言,结合丰富的示例代码,将复杂的Node.js技术讲解得浅显易懂。读者可以通过阅读本书,逐步掌握Node.js的核心概念和实际应用技巧。无论是初学者还是有一定Node.js开发经验的开发者,都可以从本书中获益。 此外,本书还包含一些实战案例,如搭建一个简单的聊天室应用、构建一个博客系统等,帮助读者将所学的理论知识应用到实际项目中。 总的来说,《深入浅出Node.js》是一本非常适合初学者入门的Node.js教程,内容全面而深入,让读者能够系统地学习和掌握Node.js的核心知识。无论是对于专业开发者还是对于程序设计感兴趣的读者,本书都是一本相当有价值的参考书籍。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值