前言
最近在学习Unity游戏设计模式，看到两本比较适合入门的书，一本是unity官方的 《Level up your programming with game programming patterns》 ,另一本是 《游戏编程模式》
这两本书介绍了大部分会使用到的设计模式，因此很值得学习
本专栏暂时先记录一些教程部分，深入阅读后续再更新
文章目录
- 前言
- 什么是对象池
- 关于生命周期管理
什么是对象池
对象池技术是老生常谈的一个概念了，很简单，无论是软件开发还是编程语言的学习中，我们都经常接触到池化技术。池化技术指的是将一些常用的变量或对象存储到一个公共池中，当我们需要调用这些变量或对象的时候，直接引用公共池中的对象而无需new一个新对象。例如管理socket的连接池，管理string的Intern字符串池，还有管理GameObject的对象池等等等等。
在Unity中，如果你想要实现发射子弹的功能，那么就需要在发射时实例化子弹预制件。但是如果使用创建Instantiate()和销毁Destory()方法来控制子弹在场景中的生命周期，这无疑是一个很浪费性能的策略，会导致游戏运行卡顿。
所以我们引入了对象池，我们在场景初始化的时候提前生成好指定数量的子弹实例，当我们发射子弹时，从对象池中取出物体，而销毁子弹时则将他们放回对象池。这样对性能的消耗就小多了。
优点是能够更好的管理物体，减少Cpu压力，减少对象生成占用堆空间导致的GC
对象池代码挺简单的，主要由三个部分组成：
1.对象池初始化代码
2.从对象池取出物体的代码
3.将物体放回对象池的代码
public class ObjPool<T> where T : new()
{
private Stack<T> ObjStack;
public ObjPool (int maxCount)
{
ObjStack = new Stack<T>(maxCount);
for (int i = 0; i < maxCount; i++)
{
var obj = new T();
ObjStack.Push(obj);
}
}
public void InPool (T obj)
{
ObjStack.Push(obj);
}
public T OutPool()
{
return ObjStack.Pop();
}
}
很简单就能手搓一个对象池，当然上述代码只是随手写的，也可也根据自己需要来写一个对象池
为什么我不介绍unity的对象池呢，因为unity太幽默了，大部分版本不支持UnityEngine.Pool这个命名空间。不过可以贴出它的代码，相比于我们的代码，就是在对象池函数更完善了，且在执行时添加了一些委托方法以供触发。
using System;
using System.Collections.Generic;
namespace UnityEngine.Pool
{
/// <summary>
/// <para>A stack based Pool.IObjectPool_1.</para>
/// </summary>
public class ObjectPool<T> : IDisposable, IObjectPool<T> where T : class
{
internal readonly List<T> m_List;
private readonly Func<T> m_CreateFunc;
private readonly Action<T> m_ActionOnGet;
private readonly Action<T> m_ActionOnRelease;
private readonly Action<T> m_ActionOnDestroy;
private readonly int m_MaxSize;
internal bool m_CollectionCheck;
public int CountAll { get; private set; }
public int CountActive => this.CountAll - this.CountInactive;
public int CountInactive => this.m_List.Count;
public ObjectPool(
Func<T> createFunc,
Action<T> actionOnGet = null,
Action<T> actionOnRelease = null,
Action<T> actionOnDestroy = null,
bool collectionCheck = true,
int defaultCapacity = 10,
int maxSize = 10000)
{
if (createFunc == null)
throw new ArgumentNullException(nameof (createFunc));
if (maxSize <= 0)
throw new ArgumentException("Max Size must be greater than 0", nameof (maxSize));
this.m_List = new List<T>(defaultCapacity);
this.m_CreateFunc = createFunc;
this.m_MaxSize = maxSize;
this.m_ActionOnGet = actionOnGet;
this.m_ActionOnRelease = actionOnRelease;
this.m_ActionOnDestroy = actionOnDestroy;
this.m_CollectionCheck = collectionCheck;
}
public T Get()
{
T obj;
if (this.m_List.Count == 0)
{
obj = this.m_CreateFunc();
++this.CountAll;
}
else
{
int index = this.m_List.Count - 1;
obj = this.m_List[index];
this.m_List.RemoveAt(index);
}
Action<T> actionOnGet = this.m_ActionOnGet;
if (actionOnGet != null)
actionOnGet(obj);
return obj;
}
public PooledObject<T> Get(out T v) => new PooledObject<T>(v = this.Get(), (IObjectPool<T>) this);
public void Release(T element)
{
if (this.m_CollectionCheck && this.m_List.Count > 0)
{
for (int index = 0; index < this.m_List.Count; ++index)
{
if ((object) element == (object) this.m_List[index])
throw new InvalidOperationException("Trying to release an object that has already been released to the pool.");
}
}
Action<T> actionOnRelease = this.m_ActionOnRelease;
if (actionOnRelease != null)
actionOnRelease(element);
if (this.CountInactive < this.m_MaxSize)
{
this.m_List.Add(element);
}
else
{
Action<T> actionOnDestroy = this.m_ActionOnDestroy;
if (actionOnDestroy != null)
actionOnDestroy(element);
}
}
public void Clear()
{
if (this.m_ActionOnDestroy != null)
{
foreach (T obj in this.m_List)
this.m_ActionOnDestroy(obj);
}
this.m_List.Clear();
this.CountAll = 0;
}
public void Dispose() => this.Clear();
}
}
关于生命周期管理
还是射击游戏的例子，现在我们要枪射出子弹，代码设计如下：
1.创建一个枪类
2.在枪类中创建一个接受子弹类的对象池
3.创建n个子弹类的预制体
那么我们该如何管理它们的生命周期？或者说上述三个类哪些需要执行MonoBehaviour的Update方法？
首先，对象池类肯定不执行Update方法，它就不该继承MonoBehaviour，我们只需要让它实现管理物体进出池的方法，对物体本身生命周期的执行不该由他执行。
子弹类可以实现Update方法吗？由于子弹类是GameObject，所以通常需要继承MonoBehaviour，但不代表生命周期函数一定由子弹类自身执行。很简单的道理，因为每个Update的存在都是对Unity 的性能消耗，假设场景里有十把枪，每把发射100发子弹，那么总计1000发子弹就得执行1000个Update方法！显然这是不合适的。
所以正常的方式是让枪类实现Update方法，并在枪类中对子弹应做的Update事件进行处理。这样10把枪就只需要10个update就能管理1000发子弹。
using UnityEngine.Pool;
public class RevisedGun : MonoBehaviour
{
…
// stack-based ObjectPool available with Unity 2021 and above
private IObjectPool<RevisedProjectile> objectPool;
// throw an exception if we try to return an existing item, already in the pool
[SerializeField] private bool collectionCheck = true;
// extra options to control the pool capacity and maximum size
[SerializeField] private int defaultCapacity = 20;
[SerializeField] private int maxSize = 100;
private void Awake()
{
objectPool = new ObjectPool<RevisedProjectile>(CreateProjectile,
OnGetFromPool, OnReleaseToPool, OnDestroyPooledObject,
collectionCheck, defaultCapacity, maxSize);
}
// invoked when creating an item to populate the object pool
private RevisedProjectile CreateProjectile()
{
RevisedProjectile projectileInstance = Instantiate(projectilePrefab);
projectileInstance.ObjectPool = objectPool;
return projectileInstance;
}
// invoked when returning an item to the object pool
private void OnReleaseToPool(RevisedProjectile pooledObject)
{
pooledObject.gameObject.SetActive(false);
}
// invoked when retrieving the next item from the object pool
private void OnGetFromPool(RevisedProjectile pooledObject)
{
pooledObject.gameObject.SetActive(true);
}
// invoked when we exceed the maximum number of pooled items (i.e. destroy the pooled object)
private void OnDestroyPooledObject(RevisedProjectile pooledObject)
{
Destroy(pooledObject.gameObject);
}
private void FixedUpdate()
{
…
}
}
还有一点，就是如果多个对象引用同一个对象池，那么我们在实现对象池代码的时候还需要注意类型安全，线程安全等特性。
