Nodejs 自己随便写的一个对象池

Nodejs 自己随便写的一个对象池

坛子里有人发了一篇关于 MongoDB 驱动的正确使用方法的文章，其中通过对象池来解决连接管理问题。文中提到使用了现有的 generic_pool 模块，但我决定自己写一个简单的对象池，主要是因为我觉得现有的模块可能没有完全解决开发过程中可能会忽略的小错误。比如，开发人员忘记在操作结束后调用 pool.release，这会导致对象池不断创建新的链接，最终可能导致资源耗尽。

对 Array 的扩展

为了方便管理和操作对象池中的对象，我们先对 JavaScript 的数组进行一些扩展：

Array.prototype.where = function(whereFunc) {
    var tmp = [];
    this.forEach(function(element) {
        if (whereFunc(element)) {
            tmp.push(element);
        }
    });
    return tmp;
};

Array.prototype.remove = function(element) {
    var elementIndex = this.indexOf(element);
    if (elementIndex > -1) {
        this.splice(elementIndex, 1);
    }
};

这些方法使得我们可以更方便地查找和删除数组中的元素。

ObjectPool.js

接下来是我们的对象池实现：

function objectPool(option) {
    var totalObjCount = 0;
    var objectPool = {
        free: [],
        busy: []
    };

    // 从对象池中获取一个对象
    this.getOne = function() {
        if (objectPool.free.length > 0) {
            var obj = objectPool.free.pop();
            obj.startBusyTime = new Date();
            objectPool.busy.push(obj);
            return obj;
        } else {
            var newObj = option.objectCreate();
            totalObjCount++;
            newObj.startBusyTime = new Date();
            objectPool.busy.push(newObj);
            return newObj;
        }
    };

    // 释放对象池中的对象
    this.freeOne = function(obj) {
        var elementIndex = objectPool.busy.indexOf(obj);
        if (elementIndex > -1) {
            objectPool.busy.remove(obj);
            objectPool.free.push(obj);
        }
    };

    // 初始化对象池
    this.init = function() {
        if (totalObjCount < option.minConnect) {
            for (var i = totalObjCount; i < option.minConnect; i++) {
                var newObj = option.objectCreate();
                totalObjCount++;
                objectPool.free.push(newObj);
            }
        }
    };

    // 对象池维护函数
    this.manager = function() {
        if (!this.managerTimmer) {
            this.managerTimmer = setInterval(function() {
                var needToFreeObjs = objectPool.busy.where(function(o) {
                    var now = new Date();
                    if ((now - o.startBusyTime) >= option.maxBusyTime) {
                        return true;
                    } else {
                        return false;
                    }
                });
                needToFreeObjs.forEach(function(o) {
                    this.freeOne(o);
                }.bind(this));

                if (totalObjCount > option.maxConnect && objectPool.free.length > 0) {
                    for (var i = totalObjCount; i > option.maxConnect && objectPool.free.length > 0; i--) {
                        var obj = objectPool.free.pop();
                        totalObjCount--;
                        option.objectRelease(obj);
                    }
                }
            }.bind(this), option.managerSpan * 1000);
        }
    };

    // 销毁对象池
    this.destroy = function() {
        objectPool.free.forEach(function(obj) {
            option.objectRelease(obj);
        });
        objectPool.free = [];

        objectPool.busy.forEach(function(obj) {
            option.objectRelease(obj);
        });
        objectPool.busy = [];
        totalObjCount = 0;
    };
}
module.exports = exports = objectPool;

使用方法

接下来是使用这个对象池的具体方法，这里以 MongoDB 为例：

var mongoSkin = require('mongoskin');
var objectPool = require('./ObjectPool.js');
var mongo = {
    hostname: '127.0.0.1',
    port: 27017,
    db: 'test'
};

var generate_mongo_url = function(obj) {
    obj.hostname = obj.hostname || 'localhost';
    obj.port = obj.port || 27017;
    obj.db = obj.db || 'test';
    if (obj.username && obj.password) {
        return obj.username + ':' + obj.password + '@' + obj.hostname + ':' + obj.port + '/' + obj.db;
    } else {
        return obj.hostname + ':' + obj.port + '/' + obj.db;
    }
};

var poolOption = {
    minConnect: 5,
    maxConnect: 50,
    managerSpan: 120,  // 维护周期（秒）
    maxBusyTime: 60000, // 最大工作时间（毫秒）
    objectCreate: function() {
        return mongoSkin.db(generate_mongo_url(mongo));
    },
    objectRelease: function(obj) {
        obj.close();
    }
};

var dbPool = new objectPool(poolOption);  // 创建对象池
dbPool.manager();  // 开始对象池维护
process.on('exit', function() {
    dbPool.destroy(); // 程序退出时销毁对象池
});

function DBConnection() {
    this.open = function() {
        if (!this.db) {
            this.db = dbPool.getOne();
        }
        return this;
    };

    this.close = function() {
        if (this.db) {
            dbPool.freeOne(this.db);
            this.db = null;
        }
    };
};

exports.DBConnection = DBConnection;

var dbConnection = new DBConnection().open();

dbConnection.db.collection('category').find({}, function(err, cs) {
    dbConnection.close(); // 这里可以不写，超过最大工作时间后资源会自动归入空闲队列
    // TODO
});

通过这种方式，我们可以有效地管理和复用数据库连接，避免了频繁创建和关闭连接导致的性能损耗。