ObjectPoolManager.ObjectPool.cs 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637
  1. //------------------------------------------------------------
  2. // Game Framework
  3. // Copyright © 2013-2021 loyalsoft. All rights reserved.
  4. // Homepage: http://www.game7000.com/
  5. // Feedback: http://www.game7000.com/
  6. //------------------------------------------------------------
  7. using System;
  8. using System.Collections.Generic;
  9. namespace GameFramework.ObjectPool
  10. {
  11. internal sealed partial class ObjectPoolManager : GameFrameworkModule, IObjectPoolManager
  12. {
  13. /// <summary>
  14. /// 对象池。
  15. /// </summary>
  16. /// <typeparam name="T">对象类型。</typeparam>
  17. private sealed class ObjectPool<T> : ObjectPoolBase, IObjectPool<T> where T : ObjectBase
  18. {
  19. private readonly GameFrameworkMultiDictionary<string, Object<T>> m_Objects;
  20. private readonly Dictionary<object, Object<T>> m_ObjectMap;
  21. private readonly ReleaseObjectFilterCallback<T> m_DefaultReleaseObjectFilterCallback;
  22. private readonly List<T> m_CachedCanReleaseObjects;
  23. private readonly List<T> m_CachedToReleaseObjects;
  24. private readonly bool m_AllowMultiSpawn;
  25. private float m_AutoReleaseInterval;
  26. private int m_Capacity;
  27. private float m_ExpireTime;
  28. private int m_Priority;
  29. private float m_AutoReleaseTime;
  30. /// <summary>
  31. /// 初始化对象池的新实例。
  32. /// </summary>
  33. /// <param name="name">对象池名称。</param>
  34. /// <param name="allowMultiSpawn">是否允许对象被多次获取。</param>
  35. /// <param name="autoReleaseInterval">对象池自动释放可释放对象的间隔秒数。</param>
  36. /// <param name="capacity">对象池的容量。</param>
  37. /// <param name="expireTime">对象池对象过期秒数。</param>
  38. /// <param name="priority">对象池的优先级。</param>
  39. public ObjectPool(string name, bool allowMultiSpawn, float autoReleaseInterval, int capacity, float expireTime, int priority)
  40. : base(name)
  41. {
  42. m_Objects = new GameFrameworkMultiDictionary<string, Object<T>>();
  43. m_ObjectMap = new Dictionary<object, Object<T>>();
  44. m_DefaultReleaseObjectFilterCallback = DefaultReleaseObjectFilterCallback;
  45. m_CachedCanReleaseObjects = new List<T>();
  46. m_CachedToReleaseObjects = new List<T>();
  47. m_AllowMultiSpawn = allowMultiSpawn;
  48. m_AutoReleaseInterval = autoReleaseInterval;
  49. Capacity = capacity;
  50. ExpireTime = expireTime;
  51. m_Priority = priority;
  52. m_AutoReleaseTime = 0f;
  53. }
  54. /// <summary>
  55. /// 获取对象池对象类型。
  56. /// </summary>
  57. public override Type ObjectType
  58. {
  59. get
  60. {
  61. return typeof(T);
  62. }
  63. }
  64. /// <summary>
  65. /// 获取对象池中对象的数量。
  66. /// </summary>
  67. public override int Count
  68. {
  69. get
  70. {
  71. return m_ObjectMap.Count;
  72. }
  73. }
  74. /// <summary>
  75. /// 获取对象池中能被释放的对象的数量。
  76. /// </summary>
  77. public override int CanReleaseCount
  78. {
  79. get
  80. {
  81. GetCanReleaseObjects(m_CachedCanReleaseObjects);
  82. return m_CachedCanReleaseObjects.Count;
  83. }
  84. }
  85. /// <summary>
  86. /// 获取是否允许对象被多次获取。
  87. /// </summary>
  88. public override bool AllowMultiSpawn
  89. {
  90. get
  91. {
  92. return m_AllowMultiSpawn;
  93. }
  94. }
  95. /// <summary>
  96. /// 获取或设置对象池自动释放可释放对象的间隔秒数。
  97. /// </summary>
  98. public override float AutoReleaseInterval
  99. {
  100. get
  101. {
  102. return m_AutoReleaseInterval;
  103. }
  104. set
  105. {
  106. m_AutoReleaseInterval = value;
  107. }
  108. }
  109. /// <summary>
  110. /// 获取或设置对象池的容量。
  111. /// </summary>
  112. public override int Capacity
  113. {
  114. get
  115. {
  116. return m_Capacity;
  117. }
  118. set
  119. {
  120. if (value < 0)
  121. {
  122. throw new GameFrameworkException("Capacity is invalid.");
  123. }
  124. if (m_Capacity == value)
  125. {
  126. return;
  127. }
  128. m_Capacity = value;
  129. Release();
  130. }
  131. }
  132. /// <summary>
  133. /// 获取或设置对象池对象过期秒数。
  134. /// </summary>
  135. public override float ExpireTime
  136. {
  137. get
  138. {
  139. return m_ExpireTime;
  140. }
  141. set
  142. {
  143. if (value < 0f)
  144. {
  145. throw new GameFrameworkException("ExpireTime is invalid.");
  146. }
  147. if (ExpireTime == value)
  148. {
  149. return;
  150. }
  151. m_ExpireTime = value;
  152. Release();
  153. }
  154. }
  155. /// <summary>
  156. /// 获取或设置对象池的优先级。
  157. /// </summary>
  158. public override int Priority
  159. {
  160. get
  161. {
  162. return m_Priority;
  163. }
  164. set
  165. {
  166. m_Priority = value;
  167. }
  168. }
  169. /// <summary>
  170. /// 创建对象。
  171. /// </summary>
  172. /// <param name="obj">对象。</param>
  173. /// <param name="spawned">对象是否已被获取。</param>
  174. public void Register(T obj, bool spawned)
  175. {
  176. if (obj == null)
  177. {
  178. throw new GameFrameworkException("Object is invalid.");
  179. }
  180. Object<T> internalObject = Object<T>.Create(obj, spawned);
  181. m_Objects.Add(obj.Name, internalObject);
  182. m_ObjectMap.Add(obj.Target, internalObject);
  183. if (Count > m_Capacity)
  184. {
  185. Release();
  186. }
  187. }
  188. /// <summary>
  189. /// 检查对象。
  190. /// </summary>
  191. /// <returns>要检查的对象是否存在。</returns>
  192. public bool CanSpawn()
  193. {
  194. return CanSpawn(string.Empty);
  195. }
  196. /// <summary>
  197. /// 检查对象。
  198. /// </summary>
  199. /// <param name="name">对象名称。</param>
  200. /// <returns>要检查的对象是否存在。</returns>
  201. public bool CanSpawn(string name)
  202. {
  203. if (name == null)
  204. {
  205. throw new GameFrameworkException("Name is invalid.");
  206. }
  207. GameFrameworkLinkedListRange<Object<T>> objectRange = default(GameFrameworkLinkedListRange<Object<T>>);
  208. if (m_Objects.TryGetValue(name, out objectRange))
  209. {
  210. foreach (Object<T> internalObject in objectRange)
  211. {
  212. if (m_AllowMultiSpawn || !internalObject.IsInUse)
  213. {
  214. return true;
  215. }
  216. }
  217. }
  218. return false;
  219. }
  220. /// <summary>
  221. /// 获取对象。
  222. /// </summary>
  223. /// <returns>要获取的对象。</returns>
  224. public T Spawn()
  225. {
  226. return Spawn(string.Empty);
  227. }
  228. /// <summary>
  229. /// 获取对象。
  230. /// </summary>
  231. /// <param name="name">对象名称。</param>
  232. /// <returns>要获取的对象。</returns>
  233. public T Spawn(string name)
  234. {
  235. if (name == null)
  236. {
  237. throw new GameFrameworkException("Name is invalid.");
  238. }
  239. GameFrameworkLinkedListRange<Object<T>> objectRange = default(GameFrameworkLinkedListRange<Object<T>>);
  240. if (m_Objects.TryGetValue(name, out objectRange))
  241. {
  242. foreach (Object<T> internalObject in objectRange)
  243. {
  244. if (m_AllowMultiSpawn || !internalObject.IsInUse)
  245. {
  246. return internalObject.Spawn();
  247. }
  248. }
  249. }
  250. return null;
  251. }
  252. /// <summary>
  253. /// 回收对象。
  254. /// </summary>
  255. /// <param name="obj">要回收的对象。</param>
  256. public void Unspawn(T obj)
  257. {
  258. if (obj == null)
  259. {
  260. throw new GameFrameworkException("Object is invalid.");
  261. }
  262. Unspawn(obj.Target);
  263. }
  264. /// <summary>
  265. /// 回收对象。
  266. /// </summary>
  267. /// <param name="target">要回收的对象。</param>
  268. public void Unspawn(object target)
  269. {
  270. if (target == null)
  271. {
  272. throw new GameFrameworkException("Target is invalid.");
  273. }
  274. Object<T> internalObject = GetObject(target);
  275. if (internalObject != null)
  276. {
  277. internalObject.Unspawn();
  278. if (Count > m_Capacity && internalObject.SpawnCount <= 0)
  279. {
  280. Release();
  281. }
  282. }
  283. else
  284. {
  285. throw new GameFrameworkException(Utility.Text.Format("Can not find target in object pool '{0}', target type is '{1}', target value is '{2}'.", new TypeNamePair(typeof(T), Name), target.GetType().FullName, target));
  286. }
  287. }
  288. /// <summary>
  289. /// 设置对象是否被加锁。
  290. /// </summary>
  291. /// <param name="obj">要设置被加锁的对象。</param>
  292. /// <param name="locked">是否被加锁。</param>
  293. public void SetLocked(T obj, bool locked)
  294. {
  295. if (obj == null)
  296. {
  297. throw new GameFrameworkException("Object is invalid.");
  298. }
  299. SetLocked(obj.Target, locked);
  300. }
  301. /// <summary>
  302. /// 设置对象是否被加锁。
  303. /// </summary>
  304. /// <param name="target">要设置被加锁的对象。</param>
  305. /// <param name="locked">是否被加锁。</param>
  306. public void SetLocked(object target, bool locked)
  307. {
  308. if (target == null)
  309. {
  310. throw new GameFrameworkException("Target is invalid.");
  311. }
  312. Object<T> internalObject = GetObject(target);
  313. if (internalObject != null)
  314. {
  315. internalObject.Locked = locked;
  316. }
  317. else
  318. {
  319. throw new GameFrameworkException(Utility.Text.Format("Can not find target in object pool '{0}', target type is '{1}', target value is '{2}'.", new TypeNamePair(typeof(T), Name), target.GetType().FullName, target));
  320. }
  321. }
  322. /// <summary>
  323. /// 设置对象的优先级。
  324. /// </summary>
  325. /// <param name="obj">要设置优先级的对象。</param>
  326. /// <param name="priority">优先级。</param>
  327. public void SetPriority(T obj, int priority)
  328. {
  329. if (obj == null)
  330. {
  331. throw new GameFrameworkException("Object is invalid.");
  332. }
  333. SetPriority(obj.Target, priority);
  334. }
  335. /// <summary>
  336. /// 设置对象的优先级。
  337. /// </summary>
  338. /// <param name="target">要设置优先级的对象。</param>
  339. /// <param name="priority">优先级。</param>
  340. public void SetPriority(object target, int priority)
  341. {
  342. if (target == null)
  343. {
  344. throw new GameFrameworkException("Target is invalid.");
  345. }
  346. Object<T> internalObject = GetObject(target);
  347. if (internalObject != null)
  348. {
  349. internalObject.Priority = priority;
  350. }
  351. else
  352. {
  353. throw new GameFrameworkException(Utility.Text.Format("Can not find target in object pool '{0}', target type is '{1}', target value is '{2}'.", new TypeNamePair(typeof(T), Name), target.GetType().FullName, target));
  354. }
  355. }
  356. /// <summary>
  357. /// 释放对象。
  358. /// </summary>
  359. /// <param name="obj">要释放的对象。</param>
  360. /// <returns>释放对象是否成功。</returns>
  361. public bool ReleaseObject(T obj)
  362. {
  363. if (obj == null)
  364. {
  365. throw new GameFrameworkException("Object is invalid.");
  366. }
  367. return ReleaseObject(obj.Target);
  368. }
  369. /// <summary>
  370. /// 释放对象。
  371. /// </summary>
  372. /// <param name="target">要释放的对象。</param>
  373. /// <returns>释放对象是否成功。</returns>
  374. public bool ReleaseObject(object target)
  375. {
  376. if (target == null)
  377. {
  378. throw new GameFrameworkException("Target is invalid.");
  379. }
  380. Object<T> internalObject = GetObject(target);
  381. if (internalObject == null)
  382. {
  383. return false;
  384. }
  385. if (internalObject.IsInUse || internalObject.Locked || !internalObject.CustomCanReleaseFlag)
  386. {
  387. return false;
  388. }
  389. m_Objects.Remove(internalObject.Name, internalObject);
  390. m_ObjectMap.Remove(internalObject.Peek().Target);
  391. internalObject.Release(false);
  392. ReferencePool.Release(internalObject);
  393. return true;
  394. }
  395. /// <summary>
  396. /// 释放对象池中的可释放对象。
  397. /// </summary>
  398. public override void Release()
  399. {
  400. Release(Count - m_Capacity, m_DefaultReleaseObjectFilterCallback);
  401. }
  402. /// <summary>
  403. /// 释放对象池中的可释放对象。
  404. /// </summary>
  405. /// <param name="toReleaseCount">尝试释放对象数量。</param>
  406. public override void Release(int toReleaseCount)
  407. {
  408. Release(toReleaseCount, m_DefaultReleaseObjectFilterCallback);
  409. }
  410. /// <summary>
  411. /// 释放对象池中的可释放对象。
  412. /// </summary>
  413. /// <param name="releaseObjectFilterCallback">释放对象筛选函数。</param>
  414. public void Release(ReleaseObjectFilterCallback<T> releaseObjectFilterCallback)
  415. {
  416. Release(Count - m_Capacity, releaseObjectFilterCallback);
  417. }
  418. /// <summary>
  419. /// 释放对象池中的可释放对象。
  420. /// </summary>
  421. /// <param name="toReleaseCount">尝试释放对象数量。</param>
  422. /// <param name="releaseObjectFilterCallback">释放对象筛选函数。</param>
  423. public void Release(int toReleaseCount, ReleaseObjectFilterCallback<T> releaseObjectFilterCallback)
  424. {
  425. if (releaseObjectFilterCallback == null)
  426. {
  427. throw new GameFrameworkException("Release object filter callback is invalid.");
  428. }
  429. if (toReleaseCount < 0)
  430. {
  431. toReleaseCount = 0;
  432. }
  433. DateTime expireTime = DateTime.MinValue;
  434. if (m_ExpireTime < float.MaxValue)
  435. {
  436. expireTime = DateTime.UtcNow.AddSeconds(-m_ExpireTime);
  437. }
  438. m_AutoReleaseTime = 0f;
  439. GetCanReleaseObjects(m_CachedCanReleaseObjects);
  440. List<T> toReleaseObjects = releaseObjectFilterCallback(m_CachedCanReleaseObjects, toReleaseCount, expireTime);
  441. if (toReleaseObjects == null || toReleaseObjects.Count <= 0)
  442. {
  443. return;
  444. }
  445. foreach (T toReleaseObject in toReleaseObjects)
  446. {
  447. ReleaseObject(toReleaseObject);
  448. }
  449. }
  450. /// <summary>
  451. /// 释放对象池中的所有未使用对象。
  452. /// </summary>
  453. public override void ReleaseAllUnused()
  454. {
  455. m_AutoReleaseTime = 0f;
  456. GetCanReleaseObjects(m_CachedCanReleaseObjects);
  457. foreach (T toReleaseObject in m_CachedCanReleaseObjects)
  458. {
  459. ReleaseObject(toReleaseObject);
  460. }
  461. }
  462. /// <summary>
  463. /// 获取所有对象信息。
  464. /// </summary>
  465. /// <returns>所有对象信息。</returns>
  466. public override ObjectInfo[] GetAllObjectInfos()
  467. {
  468. List<ObjectInfo> results = new List<ObjectInfo>();
  469. foreach (KeyValuePair<string, GameFrameworkLinkedListRange<Object<T>>> objectRanges in m_Objects)
  470. {
  471. foreach (Object<T> internalObject in objectRanges.Value)
  472. {
  473. results.Add(new ObjectInfo(internalObject.Name, internalObject.Locked, internalObject.CustomCanReleaseFlag, internalObject.Priority, internalObject.LastUseTime, internalObject.SpawnCount));
  474. }
  475. }
  476. return results.ToArray();
  477. }
  478. internal override void Update(float elapseSeconds, float realElapseSeconds)
  479. {
  480. m_AutoReleaseTime += realElapseSeconds;
  481. if (m_AutoReleaseTime < m_AutoReleaseInterval)
  482. {
  483. return;
  484. }
  485. Release();
  486. }
  487. internal override void Shutdown()
  488. {
  489. foreach (KeyValuePair<object, Object<T>> objectInMap in m_ObjectMap)
  490. {
  491. objectInMap.Value.Release(true);
  492. ReferencePool.Release(objectInMap.Value);
  493. }
  494. m_Objects.Clear();
  495. m_ObjectMap.Clear();
  496. m_CachedCanReleaseObjects.Clear();
  497. m_CachedToReleaseObjects.Clear();
  498. }
  499. private Object<T> GetObject(object target)
  500. {
  501. if (target == null)
  502. {
  503. throw new GameFrameworkException("Target is invalid.");
  504. }
  505. Object<T> internalObject = null;
  506. if (m_ObjectMap.TryGetValue(target, out internalObject))
  507. {
  508. return internalObject;
  509. }
  510. return null;
  511. }
  512. private void GetCanReleaseObjects(List<T> results)
  513. {
  514. if (results == null)
  515. {
  516. throw new GameFrameworkException("Results is invalid.");
  517. }
  518. results.Clear();
  519. foreach (KeyValuePair<object, Object<T>> objectInMap in m_ObjectMap)
  520. {
  521. Object<T> internalObject = objectInMap.Value;
  522. if (internalObject.IsInUse || internalObject.Locked || !internalObject.CustomCanReleaseFlag)
  523. {
  524. continue;
  525. }
  526. results.Add(internalObject.Peek());
  527. }
  528. }
  529. private List<T> DefaultReleaseObjectFilterCallback(List<T> candidateObjects, int toReleaseCount, DateTime expireTime)
  530. {
  531. m_CachedToReleaseObjects.Clear();
  532. if (expireTime > DateTime.MinValue)
  533. {
  534. for (int i = candidateObjects.Count - 1; i >= 0; i--)
  535. {
  536. if (candidateObjects[i].LastUseTime <= expireTime)
  537. {
  538. m_CachedToReleaseObjects.Add(candidateObjects[i]);
  539. candidateObjects.RemoveAt(i);
  540. continue;
  541. }
  542. }
  543. toReleaseCount -= m_CachedToReleaseObjects.Count;
  544. }
  545. for (int i = 0; toReleaseCount > 0 && i < candidateObjects.Count; i++)
  546. {
  547. for (int j = i + 1; j < candidateObjects.Count; j++)
  548. {
  549. if (candidateObjects[i].Priority > candidateObjects[j].Priority
  550. || candidateObjects[i].Priority == candidateObjects[j].Priority && candidateObjects[i].LastUseTime > candidateObjects[j].LastUseTime)
  551. {
  552. T temp = candidateObjects[i];
  553. candidateObjects[i] = candidateObjects[j];
  554. candidateObjects[j] = temp;
  555. }
  556. }
  557. m_CachedToReleaseObjects.Add(candidateObjects[i]);
  558. toReleaseCount--;
  559. }
  560. return m_CachedToReleaseObjects;
  561. }
  562. }
  563. }
  564. }