本文为博主原创文章,欢迎转载。请保留博主链接http://blog.csdn.net/andrewfan


Unity编程标准导引-3.4 Unity中的对象池

  本节通过一个简单的射击子弹的示例来介绍Transform的用法。子弹射击本身很容易制作,只要制作一个子弹Prefab,再做一个发生器,使用发生器按频率产生子弹,即克隆子弹Prefab,然后为每个子弹写上运动逻辑就可以了。这本该是很简单的事情。不过问题来了,发射出去后的子弹如何处理?直接Destroy吗?这太浪费了,要知道Unity的Mono内存是不断增长的。就是说除了Unity内部的那些网格、贴图等等资源内存(简单说就是继承自UnityEngine下的Object的那些类),而我们自己写的C#代码继承自System下的Object,这些代码产生的内存即是Mono内存,它只增不减。同样,你不断Destroy你的Unity对象也是要消耗性能去进行回收,而子弹这种消耗品实在产生的太快了,我们必需加以控制。
  那么,我们如何控制使得不至于不断产生新的内存呢?答案就是自己写内存池。自己回收利用之前创建过的对象。所以这个章节的内容,我们将重点放在写一个比较好的内存池上。就我自己来讲,在写一份较为系统的功能代码之前,我考虑的首先不是这个框架是该如何的,而是从使用者的角度去考虑,这个代码如何写使用起来才会比较方便,同样也要考虑容易扩展、通用性强、比较安全、减少耦合等等。

本文最后结果显示如下:

3.4.1、从使用者视角给出需求

  首先,我所希望的这个内存池的代码最后使用应该是这样的。

  • Bullet a = Pool.Take<Bullet>(); //从池中立刻获取一个单元,如果单元不存在,则它需要为我立刻创建出来。返回一个Bullet脚本以便于后续控制。注意这里使用泛型,也就是说它应该可以兼容任意的脚本类型。
  • Pool.restore(a);//当使用完成Bullet之后,我可以使用此方法回收这个对象。注意这里实际上我已经把Bullet这个组件的回收等同于某个GameObject(这里是子弹的GameObject)的回收。
      使用上就差不多是这样了,希望可以有极其简单的方法来进行获取和回收操作。

3.4.2、内存池单元结构

  最简单的内存池形式,差不多就是两个List,一个处于工作状态,一个处于闲置状态。工作完毕的对象被移动到闲置状态列表,以便于后续的再次获取和利用,形成一个循环。我们这里也会设计一个结构来管理这两个List,用于处理同一类的对象。
  接下来是考虑内存池单元的形式,我们考虑到内存池单元要尽可能容易扩展,就是可以兼容任意数据类型,也就是说,假设我们的内存池单元定为Pool_Unit,那么它不能影响后续继承它的类型,那我们最好使用接口,一旦使用类,那么就已经无法兼容Unity组件,因为我们自定义的Unity组件全部继承自MonoBehavior。接下来考虑这个内存单元该具有的功能,差不多有两个基本功能要有:

  • restore();//自己主动回收,为了方便后续调用,回收操作最好自己就有。
  • getState();//获取状态,这里是指获取当前是处于工作状态还是闲置状态,也是一个标记,用于后续快速判断。因为接口中无法存储单元,这里使用变通的方法,就是留给实现去处理,接口中要求具体实现需要提供一个状态标记。
      综合内存池单元和状态标记,给出如下代码:
    1. namespace AndrewBox.Pool
    2. {
    3. public interface Pool_Unit
    4. {
    5. Pool_UnitState state();
    6. void setParentList(object parentList);
    7. void restore();
    8. }
    9. public enum Pool_Type
    10. {
    11. Idle,
    12. Work
    13. }
    14. public class Pool_UnitState
    15. {
    16. public Pool_Type InPool
    17. {
    18. get;
    19. set;
    20. }
    21. }
    22. }

    3.4.3、单元组结构

      接下来考虑单元组,也就是前面所说的针对某一类的单元进行管理的结构。它内部有两个列表,一个工作,一个闲置,单元在工作和闲置之间转换循环。它应该具有以下功能:

  • 创建新单元;使用抽象方法,不限制具体创建方法。对于Unity而言,可能需要从Prefab克隆,那么最好有方法可以从指定的Prefab模板复制创建。
  • 获取单元;从闲置表中查找,找不到则创建。
  • 回收单元;将其子单元进行回收。
      综合单元组结构的功能,给出如下代码:
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5.  
  6. namespace AndrewBox.Pool
  7. {
  8. public abstract class Pool_UnitList<T> where T:class,Pool_Unit
  9. {
  10. protected object m_template;
  11. protected List<T> m_idleList;
  12. protected List<T> m_workList;
  13. protected int m_createdNum = ;
  14. public Pool_UnitList()
  15. {
  16. m_idleList = new List<T>();
  17. m_workList = new List<T>();
  18. }
  19.  
  20. /// <summary>
  21. /// 获取一个闲置的单元,如果不存在则创建一个新的
  22. /// </summary>
  23. /// <returns>闲置单元</returns>
  24. public virtual T takeUnit<UT>() where UT:T
  25. {
  26. T unit;
  27. if (m_idleList.Count > )
  28. {
  29. unit = m_idleList[];
  30. m_idleList.RemoveAt();
  31. }
  32. else
  33. {
  34. unit = createNewUnit<UT>();
  35. unit.setParentList(this);
  36. m_createdNum++;
  37. }
  38. m_workList.Add(unit);
  39. unit.state().InPool = Pool_Type.Work;
  40. OnUnitChangePool(unit);
  41. return unit;
  42. }
  43. /// <summary>
  44. /// 归还某个单元
  45. /// </summary>
  46. /// <param name="unit">单元</param>
  47. public virtual void restoreUnit(T unit)
  48. {
  49. if (unit!=null && unit.state().InPool == Pool_Type.Work)
  50. {
  51. m_workList.Remove(unit);
  52. m_idleList.Add(unit);
  53. unit.state().InPool = Pool_Type.Idle;
  54. OnUnitChangePool(unit);
  55. }
  56. }
  57. /// <summary>
  58. /// 设置模板
  59. /// </summary>
  60. /// <typeparam name="T"></typeparam>
  61. /// <param name="template"></param>
  62. public void setTemplate(object template)
  63. {
  64. m_template = template;
  65. }
  66. protected abstract void OnUnitChangePool(T unit);
  67. protected abstract T createNewUnit<UT>() where UT : T;
  68. }
  69. }

3.4.4、内存池结构

  内存池是一些列单元组的集合,它主要使用多个单元组具体实现内存单元的回收利用。同时把接口尽可能包装的简单,以便于用户调用,因为用户只与内存池进行打交道。另外,我们最好把内存池做成一个组件,这样便于方便进行初始化、更新(目前不需要,或许未来你需要执行某种更新操作)等工作的管理。这样,我们把内存池结构继承自上个章节的BaseBehavior。获得如下代码:

  1. using AndrewBox.Comp;
  2. using System;
  3. using System.Collections.Generic;
  4. using System.Linq;
  5. using System.Text;
  6.  
  7. namespace AndrewBox.Pool
  8. {
  9. public abstract class Pool_Base<UnitType, UnitList> : BaseBehavior
  10. where UnitType : class,Pool_Unit
  11. where UnitList : Pool_UnitList<UnitType>, new()
  12. {
  13. /// <summary>
  14. /// 缓冲池,按类型存放各自分类列表
  15. /// </summary>
  16. private Dictionary<Type, UnitList> m_poolTale = new Dictionary<Type, UnitList>();
  17.  
  18. protected override void OnInitFirst()
  19. {
  20. }
  21.  
  22. protected override void OnInitSecond()
  23. {
  24.  
  25. }
  26.  
  27. protected override void OnUpdate()
  28. {
  29.  
  30. }
  31.  
  32. /// <summary>
  33. /// 获取一个空闲的单元
  34. /// </summary>
  35. public T takeUnit<T>() where T : class,UnitType
  36. {
  37. UnitList list = getList<T>();
  38. return list.takeUnit<T>() as T;
  39. }
  40.  
  41. /// <summary>
  42. /// 在缓冲池中获取指定单元类型的列表,
  43. /// 如果该单元类型不存在,则立刻创建。
  44. /// </summary>
  45. /// <typeparam name="T">单元类型</typeparam>
  46. /// <returns>单元列表</returns>
  47. public UnitList getList<T>() where T : UnitType
  48. {
  49. var t = typeof(T);
  50. UnitList list = null;
  51. m_poolTale.TryGetValue(t, out list);
  52. if (list == null)
  53. {
  54. list = createNewUnitList<T>();
  55. m_poolTale.Add(t, list);
  56. }
  57. return list;
  58. }
  59. protected abstract UnitList createNewUnitList<UT>() where UT : UnitType;
  60. }
  61. }

3.4.5、组件化

  目前为止,上述的结构都没有使用到组件,没有使用到UnityEngine,也就是说它们不受限使用于Unity组件或者普通的类。当然使用起来也会比较麻烦。由于我们实际需要的内存池单元常常用于某种具体组件对象,比如子弹,那么我们最好针对组件进一步实现。也就是说,定制一种适用于组件的内存池单元。同时也定制出相应的单元组,组件化的内存池结构。
  另外,由于闲置的单元都需要被隐藏掉,我们在组件化的内存池单元中需要设置两个GameObject节点,一个可见节点,一个隐藏节点。当组件单元工作时,其对应的GameObject被移动到可见节点下方(当然你也可以手动再根据需要修改它的父节点)。当组件单元闲置时,其对应的GameObject也会被移动到隐藏节点下方。
  综合以上,给出以下代码:

  1. using AndrewBox.Comp;
  2. using System;
  3. using System.Collections.Generic;
  4. using System.Linq;
  5. using System.Text;
  6. using UnityEngine;
  7.  
  8. namespace AndrewBox.Pool
  9. {
  10.  
  11. public class Pool_Comp:Pool_Base<Pooled_BehaviorUnit,Pool_UnitList_Comp>
  12. {
  13. [SerializeField][Tooltip("运行父节点")]
  14. protected Transform m_work;
  15. [SerializeField][Tooltip("闲置父节点")]
  16. protected Transform m_idle;
  17.  
  18. protected override void OnInitFirst()
  19. {
  20. if (m_work == null)
  21. {
  22. m_work = CompUtil.Create(m_transform, "work");
  23. }
  24. if (m_idle == null)
  25. {
  26. m_idle = CompUtil.Create(m_transform, "idle");
  27. m_idle.gameObject.SetActive(false);
  28. }
  29. }
  30.  
  31. public void OnUnitChangePool(Pooled_BehaviorUnit unit)
  32. {
  33. if (unit != null)
  34. {
  35. var inPool=unit.state().InPool;
  36. if (inPool == Pool_Type.Idle)
  37. {
  38. unit.m_transform.SetParent(m_idle);
  39. }
  40. else if (inPool == Pool_Type.Work)
  41. {
  42. unit.m_transform.SetParent(m_work);
  43. }
  44. }
  45. }
  46. protected override Pool_UnitList_Comp createNewUnitList<UT>()
  47. {
  48. Pool_UnitList_Comp list = new Pool_UnitList_Comp();
  49. list.setPool(this);
  50. return list;
  51. }
  52.  
  53. }
  54. }
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using UnityEngine;
  6.  
  7. namespace AndrewBox.Pool
  8. {
  9. public class Pool_UnitList_Comp : Pool_UnitList<Pooled_BehaviorUnit>
  10. {
  11. protected Pool_Comp m_pool;
  12. public void setPool(Pool_Comp pool)
  13. {
  14. m_pool = pool;
  15. }
  16. protected override Pooled_BehaviorUnit createNewUnit<UT>()
  17. {
  18. GameObject result_go = null;
  19. if (m_template != null && m_template is GameObject)
  20. {
  21. result_go = GameObject.Instantiate((GameObject)m_template);
  22. }
  23. else
  24. {
  25. result_go = new GameObject();
  26. result_go.name = typeof(UT).Name;
  27. }
  28. result_go.name =result_go.name + "_"+m_createdNum;
  29. UT comp = result_go.GetComponent<UT>();
  30. if (comp == null)
  31. {
  32. comp = result_go.AddComponent<UT>();
  33. }
  34. comp.DoInit();
  35. return comp;
  36. }
  37.  
  38. protected override void OnUnitChangePool(Pooled_BehaviorUnit unit)
  39. {
  40. if (m_pool != null)
  41. {
  42. m_pool.OnUnitChangePool(unit);
  43. }
  44. }
  45. }
  46. }
  1. using AndrewBox.Comp;
  2. using System;
  3. using System.Collections.Generic;
  4. using System.Linq;
  5. using System.Text;
  6.  
  7. namespace AndrewBox.Pool
  8. {
  9. public abstract class Pooled_BehaviorUnit : BaseBehavior, Pool_Unit
  10. {
  11. //单元状态对象
  12. protected Pool_UnitState m_unitState = new Pool_UnitState();
  13. //父列表对象
  14. Pool_UnitList<Pooled_BehaviorUnit> m_parentList;
  15. /// <summary>
  16. /// 返回一个单元状态,用于控制当前单元的闲置、工作状态
  17. /// </summary>
  18. /// <returns>单元状态</returns>
  19. public virtual Pool_UnitState state()
  20. {
  21. return m_unitState;
  22. }
  23. /// <summary>
  24. /// 接受父列表对象的设置
  25. /// </summary>
  26. /// <param name="parentList">父列表对象</param>
  27. public virtual void setParentList(object parentList)
  28. {
  29. m_parentList = parentList as Pool_UnitList<Pooled_BehaviorUnit>;
  30. }
  31. /// <summary>
  32. /// 归还自己,即将自己回收以便再利用
  33. /// </summary>
  34. public virtual void restore()
  35. {
  36. if (m_parentList != null)
  37. {
  38. m_parentList.restoreUnit(this);
  39. }
  40. }
  41.  
  42. }
  43. }

3.4.6、内存池单元具体化

接下来,我们将Bullet具体化为一种内存池单元,使得它可以方便从内存池中创建出来。

  1. using UnityEngine;
  2. using System.Collections;
  3. using AndrewBox.Comp;
  4. using AndrewBox.Pool;
  5.  
  6. public class Bullet : Pooled_BehaviorUnit
  7. {
  8. [SerializeField][Tooltip("移动速度")]
  9. private float m_moveVelocity=;
  10. [SerializeField][Tooltip("移动时长")]
  11. private float m_moveTime=;
  12. [System.NonSerialized][Tooltip("移动计数")]
  13. private float m_moveTimeTick;
  14. protected override void OnInitFirst()
  15. {
  16. }
  17.  
  18. protected override void OnInitSecond()
  19. {
  20. }
  21.  
  22. protected override void OnUpdate()
  23. {
  24. float deltaTime = Time.deltaTime;
  25. m_moveTimeTick += deltaTime;
  26. if (m_moveTimeTick >= m_moveTime)
  27. {
  28. m_moveTimeTick = ;
  29. this.restore();
  30. }
  31. else
  32. {
  33. var pos = m_transform.localPosition;
  34. pos.z += m_moveVelocity * deltaTime;
  35. m_transform.localPosition = pos;
  36. }
  37. }
  38. }

3.4.7、内存池的使用

最后就是写一把枪来发射子弹了,这个逻辑也相对简单。为了把内存池做成单例模式并存放在单独的GameObject,我们还需要另外一个单例单元管理器的辅助,一并给出。

  1. using UnityEngine;
  2. using System.Collections;
  3. using AndrewBox.Comp;
  4. using AndrewBox.Pool;
  5.  
  6. public class Gun_Simple : BaseBehavior
  7. {
  8.  
  9. [SerializeField][Tooltip("模板对象")]
  10. private GameObject m_bulletTemplate;
  11. [System.NonSerialized][Tooltip("组件对象池")]
  12. private Pool_Comp m_compPool;
  13. [SerializeField][Tooltip("产生间隔")]
  14. private float m_fireRate=0.5f;
  15. [System.NonSerialized][Tooltip("产生计数")]
  16. private float m_fireTick;
  17. protected override void OnInitFirst()
  18. {
  19. m_compPool = Singletons.Get<Pool_Comp>("pool_comps");
  20. m_compPool.getList<Bullet>().setTemplate(m_bulletTemplate);
  21. }
  22.  
  23. protected override void OnInitSecond()
  24. {
  25.  
  26. }
  27.  
  28. protected override void OnUpdate()
  29. {
  30. m_fireTick -= Time.deltaTime;
  31. if (m_fireTick < )
  32. {
  33. m_fireTick += m_fireRate;
  34. fire();
  35. }
  36. }
  37. protected void fire()
  38. {
  39. Bullet bullet = m_compPool.takeUnit<Bullet>();
  40. bullet.m_transform.position = m_transform.position;
  41. bullet.m_transform.rotation = m_transform.rotation;
  42. }
  43. }
  1. using AndrewBox.Comp;
  2. using System;
  3. using System.Collections.Generic;
  4. using System.Linq;
  5. using System.Text;
  6. using UnityEngine;
  7.  
  8. namespace AndrewBox.Comp
  9. {
  10. /// <summary>
  11. /// 单例单元管理器
  12. /// 你可以创建单例组件,每个单例组件对应一个GameObject。
  13. /// 你可以为单例命名,名字同时也会作为GameObject的名字。
  14. /// 这些产生的单例一般用作管理器。
  15. /// </summary>
  16. public static class Singletons
  17. {
  18. private static Dictionary<string, BaseBehavior> m_singletons = new Dictionary<string, BaseBehavior>();
  19. public static T Get<T>(string name) where T:BaseBehavior
  20. {
  21.  
  22. BaseBehavior singleton = null;
  23. m_singletons.TryGetValue(name, out singleton);
  24. if (singleton == null)
  25. {
  26. GameObject newGo = new GameObject(name);
  27. singleton = newGo.AddComponent<T>();
  28. m_singletons.Add(name, singleton);
  29. }
  30. return singleton as T;
  31. }
  32. public static void Destroy(string name)
  33. {
  34. BaseBehavior singleton = null;
  35. m_singletons.TryGetValue(name, out singleton);
  36. if (singleton != null)
  37. {
  38. m_singletons.Remove(name);
  39. GameObject.DestroyImmediate(singleton.gameObject);
  40. }
  41. }
  42. public static void Clear()
  43. {
  44. List<string> keys = new List<string>();
  45. foreach (var key in m_singletons.Keys)
  46. {
  47. keys.Add(key);
  48. }
  49. foreach (var key in keys)
  50. {
  51. Destroy(key);
  52. }
  53. }
  54.  
  55. }
  56. }

3.4.8、总结

最终,我们写出了所有的代码,这个内存池是通用的,而且整个游戏工程,你几乎只需要这样的一个内存池,就可以管理所有的数量众多且种类繁多的活动单元。而调用处只有以下几行代码即可轻松管理。

  1. m_compPool = Singletons.Get<Pool_Comp>("pool_comps");//创建内存池
  2. m_compPool.getList<Bullet>().setTemplate(m_bulletTemplate);//设置模板
  3. Bullet bullet = m_compPool.takeUnit<Bullet>();//索取单元
  4. bullet.restore(); //回收单元

最终当你正确使用它时,你的GameObject内存不会再无限制增长,它将出现类似的下图循环利用。

对象池

本例完整项目资源请参见我的CSDN博客:http://blog.csdn.net/andrewfan

本文为博主原创文章,欢迎转载。请保留博主链接:http://blog.csdn.net/andrewfan

Unity中的万能对象池的更多相关文章

  1. c++实现游戏开发中常用的对象池(含源码)

    c++实现游戏开发中常用的对象池(含源码) little_stupid_child2017-01-06上传   对象池的五要素: 1.对象集合 2.未使用对象索引集合 3.已使用对象索引集合 4.当前 ...

  2. Unity实现简单的对象池

    一.简介 先说说为什么要使用对象池 在Unity游戏运行时,经常需要生成一些物体,例如子弹.敌人等.虽然Unity中有Instantiate()方法可以使用,但是在某些情况下并不高效.特别是对于那些需 ...

  3. unity游戏开发_对象池

    现在假设游戏中我们需要实现一个这样功能,按下鼠标左键,发射一颗子弹,3秒之后消失.在这个功能中,我们发射了上百上千发子弹,就需要实例化生成上百上千次.这时候,我们就需要使用对象池这个概念,每次实例化生 ...

  4. 【Fungus入门】10分钟快速构建Unity中的万能对话系统 / 叙事系统 / 剧情系统

    我真的很久没有写过一个完整的攻略了(笑),咸鱼了很久之后还是想来写一个好玩的.这次主要是梳理一下Unity的小众插件Fungus的核心功能,并且快速掌握其使用方法. 官方文档:http://fungu ...

  5. Unity中销毁游戏对象的方式

    销毁方式 销毁物体的方式有两种:Destroy和DestroyImmediate两种,那两者有什么区别呢?细听分说. 两种方式都能达到销毁物体的目的,有以下区别: Destroy销毁场景中的物体但是内 ...

  6. 在C#中实现简单的对象池

    当我们频繁创建删除大量对象的时候,对象的创建删除所造成的开销就不容小觑了.为了提高性能,我们往往需要实现一个对象池作为Cache:使用对象时,它从池中提取.用完对象时,它放回池中.从而减少创建对象的开 ...

  7. 游戏设计模式——Unity对象池

    对象池这个名字听起来很玄乎,其实就是将一系列需要反复创建和销毁的对象存储在一个看不到的地方,下次用同样的东西时往这里取,类似于一个存放备用物质的仓库. 它的好处就是避免了反复实例化个体的运算,能减少大 ...

  8. 对象池在 .NET (Core)中的应用[1]: 编程体验

    借助于有效的自动化垃圾回收机制,.NET让开发人员不在关心对象的生命周期,但实际上很多性能问题都来源于GC.并不说.NET的GC有什么问题,而是对象生命周期的跟踪和管理本身是需要成本的,不论交给应用还 ...

  9. 对象池在 .NET (Core)中的应用[2]: 设计篇

    <编程篇>已经涉及到了对象池模型的大部分核心接口和类型.对象池模型其实是很简单的,不过其中有一些为了提升性能而刻意为之的实现细节倒是值得我们关注.总的来说,对象池模型由三个核心对象构成,它 ...

随机推荐

  1. 【转】25个Git用法技巧

    Andy Jeffries 给 Git 中级用户总结分享的 25 个小贴士.你不需要去做大量搜索,或许这些小贴士对你就很有帮助的. 我从开始使用git到现在已经差不多18个月了,以为自己已经很懂git ...

  2. Memcached源码分析之assoc.c

    #include "memcached.h" #include <sys/stat.h> #include <sys/socket.h> #include ...

  3. MYsql数据库ERROR总结

    描述:#Warning: Using a password on the command line interface can be insecure.#ERROR 1045 (28000): Acc ...

  4. AppBarLayout学习笔记

    LinearLayout的子类 AppBarLayout要点: 功能:让子View(AppBar)可以选择他们自己的滚动行为. 注意:需要依赖CoordinatorLayout作为父容器,同时也要求一 ...

  5. Jconsole连接远程服务器

    本地服务器.win7,安装JDK8 远程服务器:centos6.5 ,tomcat7,java8 配置方法: 1)修改远程服务器的~/tomcat/bin/catalina.sh  文件 在 # -- ...

  6. windowsxp系统下SVN添加新用户

    以我部署的文件为例: 我在f盘下新建一个zzz文件夹将其部署为svn共享工程后,新来员工需要添加svn账号以获取工程. 总共三步begin: 1.进入工程文件夹ZZZ在里面有一个conf文件夹如图: ...

  7. Java IO面试

    1. 讲讲IO里面的常见类,字节流.字符流.接口.实现类.方法阻塞. 字节流和字符流的区别: 1)字节流处理单元为1个字节,操作字节和字节数组,而字符流处理的单元为2个字节的Unicode字符,分别操 ...

  8. 前言(Core Data 应用开发实践指南)

    Core Data 并不是数据库,它其实是一个拥有多种功能的框架.其中,有个功能是把程序与数据库之间的交互过程自动化,不用再编写SQL代码,改用Objective-C对象来实现. Core Data ...

  9. Java语言中IO流的操作规律学习笔记

    1,明确源和目的. 数据源:就是需要读取,可以使用两个体系:InputStream.Reader: 数据汇:就是需要写入,可以使用两个体系:OutputStream.Writer: 总结: 读:就是把 ...

  10. MongoDB_GridFS_存储文件

    GridFS mongoDB除了保存各种文档(JOSN结构)外还能够保存文件.GridFS规范提供了一种透明机制,可以将一个大文件分割成为多个较小的文档,这样的机制允许我们有效的保存大文件对象,特别对 ...