unity 对象池

对象池背后的理念其实是非常简单的。我们将对象存储在一个池子中，当需要时在再次使用，而不是每次都实例化一个新的对象。池的最重要的特性，也就是对象池设计模式的本质是允许我们获取一个“新的”对象而不管它真的是一个新的对象还是循环使用的对象。

这是网上找的解释。
我们游戏中大量用到了对象池。
今天看了下对象池底层的代码。下面这篇文章写得挺好

http://www.cnblogs.com/mezero/p/3955130.html

废话不多说，上我们自己的对象池代码。

using System;
using UnityEngine;
using System.Collections;
using System.Collections.Generic;

// 清0操作由调用者负责编写
// 提供对非unity对象的缓存，即逻辑对象缓存
// 注意必须是class哈
// 提供接口 IObjectClear, Release时自动调用

public interface IObjectClear
{
void Clear();
}

public class ObjectPool
{
class ObjectGroup
{
public Stack<object> m_freeStack;
public int m_iMaxNum;  // 最大数量，为0表示不限制，否则超过最大数量，Release时直接delete

public ObjectGroup()
{
m_freeStack = new Stack<object>();
m_iMaxNum = 0;
}
}

Dictionary< Type,   ObjectGroup > m_typeDic;
object m_locker = new object();
bool m_bIsthreadSafe;

public ObjectPool(bool bIsthreadSafe = false)
{
m_typeDic = new Dictionary< Type,   ObjectGroup >();
m_bIsthreadSafe = bIsthreadSafe;
}

public void Register<T>( int iInitNum, int iMaxNum = 0 ) where T : class, new()
{
if (iInitNum < 0)
{
throw new ArgumentException("Init num < 0");
}

ObjectGroup group = null;
if ( m_typeDic.TryGetValue(typeof(T), out group) )
{
// 已存在
return;
}

group = new ObjectGroup();
group.m_iMaxNum = iMaxNum;

if (iInitNum > 0)
{
for (int i = 0; i < iInitNum; i++)
{
T obj = new T();
if (m_bIsthreadSafe)
{
lock (m_locker)
{
group.m_freeStack.Push(obj);
}
}
else
{
group.m_freeStack.Push(obj);
}
}
}

m_typeDic[typeof(T)] = group;
}

public T Get<T>() where T : class, new()
{
ObjectGroup group = null;
if (!m_typeDic.TryGetValue(typeof(T), out group))
{
Register<T>(1);
return Get<T>();
}

T obj = null;
if (0 == group.m_freeStack.Count)
{
obj = new T();
}else
{
if (m_bIsthreadSafe)
{
lock (m_locker)
{
obj = group.m_freeStack.Pop() as T;
}
}
else
{
obj = group.m_freeStack.Pop() as T;
}
}

return obj;
}

public void Release<T>(T obj) where T : class, new()
{
if (null == obj)
{
throw new ArgumentException("obj is null!!");
}

ObjectGroup group = null;
Type t = ((object)obj).GetType();
if (!m_typeDic.TryGetValue(t, out group))
{
throw new ArgumentException("obj's type is not registered!");
}

if (obj is IObjectClear)
{
((IObjectClear)obj).Clear();
}

if (group.m_iMaxNum > 0 && group.m_freeStack.Count >= group.m_iMaxNum)
{
if (obj is IDisposable)
{
((IDisposable)obj).Dispose();
}

obj = null;
System.GC.Collect();
}
else
{
// add to free list
if (m_bIsthreadSafe)
{
lock (m_locker)
{
group.m_freeStack.Push(obj);
}
}
else
{
group.m_freeStack.Push(obj);
}
}
}

private void _DestroyGroup( ObjectGroup group )
{
object obj = null;
while (group.m_freeStack.Count > 0)
{
if (m_bIsthreadSafe)
{
lock (m_locker)
{
obj = group.m_freeStack.Pop();
}
}
else
{
obj = group.m_freeStack.Pop();
}

if (obj is IDisposable)
{
((IDisposable)obj).Dispose();
}
obj = null;
}
if (m_bIsthreadSafe)
{
lock (m_locker)
{
group.m_freeStack.Clear();
}
}
else
{
group.m_freeStack.Clear();
}
}

public void DestroyType<T>() where T : class, new()
{
ObjectGroup group = null;
if (!m_typeDic.TryGetValue(typeof(T), out group))
{
throw new ArgumentException("obj's type is not registered!");
}

this._DestroyGroup(group);
}

// destroy所有实列
public void DestroyAll()
{
foreach (var it in m_typeDic)
{
ObjectGroup group = it.Value;
this._DestroyGroup(group);
group = null;
}

m_typeDic.Clear();

System.GC.Collect();
}
}