一个通用Typescript对象池

ObjectPool.ts

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
/**
 * 可以加入对象池的对象
 *
 * @export
 * @interface IPoolObject
 */
export interface IPoolObject {
    /**
     * 重置的方法
     *
     * @memberof IPoolObject
     */
    reset() : void
}

/**
 * 对象池
 *
 * @export
 * @class ObjectPool
 */
export class ObjectPool {
    private static _instance: ObjectPool
    private constructor() {}
    static get Inst() : ObjectPool {
        if (!ObjectPool._instance) {
            ObjectPool._instance = new ObjectPool()
        }
        return ObjectPool._instance
    }
    private _poolMap: Map<any, Array<any>> = new Map<any, Array<any>>()
    
    /**
     * 释放有对象池
     *
     * @template T
     * @param {{ new(): T}} Class
     * @returns {boolean}
     * @memberof ObjectPool
     */
    hasPool<T extends IPoolObject>(Class: { new(): T}) : boolean {
        return !!this._poolMap.get(Class)
    }

    /**
     * 加入对象池
     *
     * @template T
     * @param {T} obj
     * @memberof ObjectPool
     */
    put<T extends IPoolObject>(obj: T) : void {
        if (!this._poolMap.get(obj)) {
            this._poolMap.set(obj, new Array<T>())
        }
        // 重置对象
        obj.reset()
        this._poolMap.get(obj.constructor).push(obj)
    }

    /**
     * 取出数据
     *
     * @template T
     * @param {{ new(): T }} Class
     * @returns {T}
     * @memberof ObjectPool
     */
    get<T extends IPoolObject>(Class:{ new(): T }) : T {
        if (!this._poolMap.get(Class)) {
            this._poolMap.set(Class, new Array<T>())
        }
        let pool = this._poolMap.get(Class)
        if (!pool.length) {
            this._factoryCreate(Class, pool)
        }
        return pool.pop()
    }

    /**
     * 初始化对象池
     *
     * @template T
     * @param {{ new(): T}} Class
     * @param {number} [count=10]
     * @memberof ObjectPool
     */
    initPool<T extends IPoolObject>(Class: { new(): T}, count: number = 10) : void{
        if (!this._poolMap.get(Class)) {
            this._poolMap.set(Class, new Array<T>())
        }
        let pool = this._poolMap.get(Class)
        if (!pool.length) {
            this._factoryCreate(Class, pool, count)
        }
    }

    /**
     * 清除所有
     *
     * @memberof ObjectPool
     */
    clearAll() {
        // TODO 如果需要释放资源 在这里做
        this._poolMap = new Map<any, Array<any>>()
    }

    /**
     * 批量创建对象
     *
     * @private
     * @template T
     * @param {{ new(): T}} Class
     * @param {number} [count=10]
     * @memberof ObjectPool
     */
    private _factoryCreate<T> (Class: { new(): T}, pool: Array<T>, count: number = 10) : void {
        for (let i = 0; i < count; i++) {
            pool.push(new Class())
        }
    }

}
游戏编程
game typescript

本博客所有文章除特别声明外，均采用 CC BY-SA 4.0 协议 ，转载请注明出处！