TaskPool.cs 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444
  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.Collections.Generic;
  8. namespace GameFramework
  9. {
  10. /// <summary>
  11. /// 任务池。
  12. /// </summary>
  13. /// <typeparam name="T">任务类型。</typeparam>
  14. internal sealed class TaskPool<T> where T : TaskBase
  15. {
  16. private readonly Stack<ITaskAgent<T>> m_FreeAgents;
  17. private readonly GameFrameworkLinkedList<ITaskAgent<T>> m_WorkingAgents;
  18. private readonly GameFrameworkLinkedList<T> m_WaitingTasks;
  19. private bool m_Paused;
  20. /// <summary>
  21. /// 初始化任务池的新实例。
  22. /// </summary>
  23. public TaskPool()
  24. {
  25. m_FreeAgents = new Stack<ITaskAgent<T>>();
  26. m_WorkingAgents = new GameFrameworkLinkedList<ITaskAgent<T>>();
  27. m_WaitingTasks = new GameFrameworkLinkedList<T>();
  28. m_Paused = false;
  29. }
  30. /// <summary>
  31. /// 获取或设置任务池是否被暂停。
  32. /// </summary>
  33. public bool Paused
  34. {
  35. get
  36. {
  37. return m_Paused;
  38. }
  39. set
  40. {
  41. m_Paused = value;
  42. }
  43. }
  44. /// <summary>
  45. /// 获取任务代理总数量。
  46. /// </summary>
  47. public int TotalAgentCount
  48. {
  49. get
  50. {
  51. return FreeAgentCount + WorkingAgentCount;
  52. }
  53. }
  54. /// <summary>
  55. /// 获取可用任务代理数量。
  56. /// </summary>
  57. public int FreeAgentCount
  58. {
  59. get
  60. {
  61. return m_FreeAgents.Count;
  62. }
  63. }
  64. /// <summary>
  65. /// 获取工作中任务代理数量。
  66. /// </summary>
  67. public int WorkingAgentCount
  68. {
  69. get
  70. {
  71. return m_WorkingAgents.Count;
  72. }
  73. }
  74. /// <summary>
  75. /// 获取等待任务数量。
  76. /// </summary>
  77. public int WaitingTaskCount
  78. {
  79. get
  80. {
  81. return m_WaitingTasks.Count;
  82. }
  83. }
  84. /// <summary>
  85. /// 任务池轮询。
  86. /// </summary>
  87. /// <param name="elapseSeconds">逻辑流逝时间,以秒为单位。</param>
  88. /// <param name="realElapseSeconds">真实流逝时间,以秒为单位。</param>
  89. public void Update(float elapseSeconds, float realElapseSeconds)
  90. {
  91. if (m_Paused)
  92. {
  93. return;
  94. }
  95. ProcessRunningTasks(elapseSeconds, realElapseSeconds);
  96. ProcessWaitingTasks(elapseSeconds, realElapseSeconds);
  97. }
  98. /// <summary>
  99. /// 关闭并清理任务池。
  100. /// </summary>
  101. public void Shutdown()
  102. {
  103. RemoveAllTasks();
  104. while (FreeAgentCount > 0)
  105. {
  106. m_FreeAgents.Pop().Shutdown();
  107. }
  108. }
  109. /// <summary>
  110. /// 增加任务代理。
  111. /// </summary>
  112. /// <param name="agent">要增加的任务代理。</param>
  113. public void AddAgent(ITaskAgent<T> agent)
  114. {
  115. if (agent == null)
  116. {
  117. throw new GameFrameworkException("Task agent is invalid.");
  118. }
  119. agent.Initialize();
  120. m_FreeAgents.Push(agent);
  121. }
  122. /// <summary>
  123. /// 根据任务的序列编号获取任务的信息。
  124. /// </summary>
  125. /// <param name="serialId">要获取信息的任务的序列编号。</param>
  126. /// <returns>任务的信息。</returns>
  127. public TaskInfo GetTaskInfo(int serialId)
  128. {
  129. foreach (ITaskAgent<T> workingAgent in m_WorkingAgents)
  130. {
  131. T workingTask = workingAgent.Task;
  132. if (workingTask.SerialId == serialId)
  133. {
  134. return new TaskInfo(workingTask.SerialId, workingTask.Tag, workingTask.Priority, workingTask.UserData, workingTask.Done ? TaskStatus.Done : TaskStatus.Doing, workingTask.Description);
  135. }
  136. }
  137. foreach (T waitingTask in m_WaitingTasks)
  138. {
  139. if (waitingTask.SerialId == serialId)
  140. {
  141. return new TaskInfo(waitingTask.SerialId, waitingTask.Tag, waitingTask.Priority, waitingTask.UserData, TaskStatus.Todo, waitingTask.Description);
  142. }
  143. }
  144. return default(TaskInfo);
  145. }
  146. /// <summary>
  147. /// 根据任务的标签获取任务的信息。
  148. /// </summary>
  149. /// <param name="tag">要获取信息的任务的标签。</param>
  150. /// <returns>任务的信息。</returns>
  151. public TaskInfo[] GetTaskInfos(string tag)
  152. {
  153. List<TaskInfo> results = new List<TaskInfo>();
  154. GetTaskInfos(tag, results);
  155. return results.ToArray();
  156. }
  157. /// <summary>
  158. /// 根据任务的标签获取任务的信息。
  159. /// </summary>
  160. /// <param name="tag">要获取信息的任务的标签。</param>
  161. /// <param name="results">任务的信息。</param>
  162. public void GetTaskInfos(string tag, List<TaskInfo> results)
  163. {
  164. if (results == null)
  165. {
  166. throw new GameFrameworkException("Results is invalid.");
  167. }
  168. results.Clear();
  169. foreach (ITaskAgent<T> workingAgent in m_WorkingAgents)
  170. {
  171. T workingTask = workingAgent.Task;
  172. if (workingTask.Tag == tag)
  173. {
  174. results.Add(new TaskInfo(workingTask.SerialId, workingTask.Tag, workingTask.Priority, workingTask.UserData, workingTask.Done ? TaskStatus.Done : TaskStatus.Doing, workingTask.Description));
  175. }
  176. }
  177. foreach (T waitingTask in m_WaitingTasks)
  178. {
  179. if (waitingTask.Tag == tag)
  180. {
  181. results.Add(new TaskInfo(waitingTask.SerialId, waitingTask.Tag, waitingTask.Priority, waitingTask.UserData, TaskStatus.Todo, waitingTask.Description));
  182. }
  183. }
  184. }
  185. /// <summary>
  186. /// 获取所有任务的信息。
  187. /// </summary>
  188. /// <returns>所有任务的信息。</returns>
  189. public TaskInfo[] GetAllTaskInfos()
  190. {
  191. int index = 0;
  192. TaskInfo[] results = new TaskInfo[m_WorkingAgents.Count + m_WaitingTasks.Count];
  193. foreach (ITaskAgent<T> workingAgent in m_WorkingAgents)
  194. {
  195. T workingTask = workingAgent.Task;
  196. results[index++] = new TaskInfo(workingTask.SerialId, workingTask.Tag, workingTask.Priority, workingTask.UserData, workingTask.Done ? TaskStatus.Done : TaskStatus.Doing, workingTask.Description);
  197. }
  198. foreach (T waitingTask in m_WaitingTasks)
  199. {
  200. results[index++] = new TaskInfo(waitingTask.SerialId, waitingTask.Tag, waitingTask.Priority, waitingTask.UserData, TaskStatus.Todo, waitingTask.Description);
  201. }
  202. return results;
  203. }
  204. /// <summary>
  205. /// 获取所有任务的信息。
  206. /// </summary>
  207. /// <param name="results">所有任务的信息。</param>
  208. public void GetAllTaskInfos(List<TaskInfo> results)
  209. {
  210. if (results == null)
  211. {
  212. throw new GameFrameworkException("Results is invalid.");
  213. }
  214. results.Clear();
  215. foreach (ITaskAgent<T> workingAgent in m_WorkingAgents)
  216. {
  217. T workingTask = workingAgent.Task;
  218. results.Add(new TaskInfo(workingTask.SerialId, workingTask.Tag, workingTask.Priority, workingTask.UserData, workingTask.Done ? TaskStatus.Done : TaskStatus.Doing, workingTask.Description));
  219. }
  220. foreach (T waitingTask in m_WaitingTasks)
  221. {
  222. results.Add(new TaskInfo(waitingTask.SerialId, waitingTask.Tag, waitingTask.Priority, waitingTask.UserData, TaskStatus.Todo, waitingTask.Description));
  223. }
  224. }
  225. /// <summary>
  226. /// 增加任务。
  227. /// </summary>
  228. /// <param name="task">要增加的任务。</param>
  229. public void AddTask(T task)
  230. {
  231. LinkedListNode<T> current = m_WaitingTasks.Last;
  232. while (current != null)
  233. {
  234. if (task.Priority <= current.Value.Priority)
  235. {
  236. break;
  237. }
  238. current = current.Previous;
  239. }
  240. if (current != null)
  241. {
  242. m_WaitingTasks.AddAfter(current, task);
  243. }
  244. else
  245. {
  246. m_WaitingTasks.AddFirst(task);
  247. }
  248. }
  249. /// <summary>
  250. /// 根据任务的序列编号移除任务。
  251. /// </summary>
  252. /// <param name="serialId">要移除任务的序列编号。</param>
  253. /// <returns>是否移除任务成功。</returns>
  254. public bool RemoveTask(int serialId)
  255. {
  256. foreach (T task in m_WaitingTasks)
  257. {
  258. if (task.SerialId == serialId)
  259. {
  260. m_WaitingTasks.Remove(task);
  261. ReferencePool.Release(task);
  262. return true;
  263. }
  264. }
  265. LinkedListNode<ITaskAgent<T>> currentWorkingAgent = m_WorkingAgents.First;
  266. while (currentWorkingAgent != null)
  267. {
  268. LinkedListNode<ITaskAgent<T>> next = currentWorkingAgent.Next;
  269. ITaskAgent<T> workingAgent = currentWorkingAgent.Value;
  270. T task = workingAgent.Task;
  271. if (task.SerialId == serialId)
  272. {
  273. workingAgent.Reset();
  274. m_FreeAgents.Push(workingAgent);
  275. m_WorkingAgents.Remove(currentWorkingAgent);
  276. ReferencePool.Release(task);
  277. return true;
  278. }
  279. currentWorkingAgent = next;
  280. }
  281. return false;
  282. }
  283. /// <summary>
  284. /// 根据任务的标签移除任务。
  285. /// </summary>
  286. /// <param name="tag">要移除任务的标签。</param>
  287. /// <returns>移除任务的数量。</returns>
  288. public int RemoveTasks(string tag)
  289. {
  290. int count = 0;
  291. LinkedListNode<T> currentWaitingTask = m_WaitingTasks.First;
  292. while (currentWaitingTask != null)
  293. {
  294. LinkedListNode<T> next = currentWaitingTask.Next;
  295. T task = currentWaitingTask.Value;
  296. if (task.Tag == tag)
  297. {
  298. m_WaitingTasks.Remove(currentWaitingTask);
  299. ReferencePool.Release(task);
  300. count++;
  301. }
  302. currentWaitingTask = next;
  303. }
  304. LinkedListNode<ITaskAgent<T>> currentWorkingAgent = m_WorkingAgents.First;
  305. while (currentWorkingAgent != null)
  306. {
  307. LinkedListNode<ITaskAgent<T>> next = currentWorkingAgent.Next;
  308. ITaskAgent<T> workingAgent = currentWorkingAgent.Value;
  309. T task = workingAgent.Task;
  310. if (task.Tag == tag)
  311. {
  312. workingAgent.Reset();
  313. m_FreeAgents.Push(workingAgent);
  314. m_WorkingAgents.Remove(currentWorkingAgent);
  315. ReferencePool.Release(task);
  316. count++;
  317. }
  318. currentWorkingAgent = next;
  319. }
  320. return count;
  321. }
  322. /// <summary>
  323. /// 移除所有任务。
  324. /// </summary>
  325. /// <returns>移除任务的数量。</returns>
  326. public int RemoveAllTasks()
  327. {
  328. int count = m_WaitingTasks.Count + m_WorkingAgents.Count;
  329. foreach (T task in m_WaitingTasks)
  330. {
  331. ReferencePool.Release(task);
  332. }
  333. m_WaitingTasks.Clear();
  334. foreach (ITaskAgent<T> workingAgent in m_WorkingAgents)
  335. {
  336. T task = workingAgent.Task;
  337. workingAgent.Reset();
  338. m_FreeAgents.Push(workingAgent);
  339. ReferencePool.Release(task);
  340. }
  341. m_WorkingAgents.Clear();
  342. return count;
  343. }
  344. private void ProcessRunningTasks(float elapseSeconds, float realElapseSeconds)
  345. {
  346. LinkedListNode<ITaskAgent<T>> current = m_WorkingAgents.First;
  347. while (current != null)
  348. {
  349. T task = current.Value.Task;
  350. if (!task.Done)
  351. {
  352. current.Value.Update(elapseSeconds, realElapseSeconds);
  353. current = current.Next;
  354. continue;
  355. }
  356. LinkedListNode<ITaskAgent<T>> next = current.Next;
  357. current.Value.Reset();
  358. m_FreeAgents.Push(current.Value);
  359. m_WorkingAgents.Remove(current);
  360. ReferencePool.Release(task);
  361. current = next;
  362. }
  363. }
  364. private void ProcessWaitingTasks(float elapseSeconds, float realElapseSeconds)
  365. {
  366. LinkedListNode<T> current = m_WaitingTasks.First;
  367. while (current != null && FreeAgentCount > 0)
  368. {
  369. ITaskAgent<T> agent = m_FreeAgents.Pop();
  370. LinkedListNode<ITaskAgent<T>> agentNode = m_WorkingAgents.AddLast(agent);
  371. T task = current.Value;
  372. LinkedListNode<T> next = current.Next;
  373. StartTaskStatus status = agent.Start(task);
  374. if (status == StartTaskStatus.Done || status == StartTaskStatus.HasToWait || status == StartTaskStatus.UnknownError)
  375. {
  376. agent.Reset();
  377. m_FreeAgents.Push(agent);
  378. m_WorkingAgents.Remove(agentNode);
  379. }
  380. if (status == StartTaskStatus.Done || status == StartTaskStatus.CanResume || status == StartTaskStatus.UnknownError)
  381. {
  382. m_WaitingTasks.Remove(current);
  383. }
  384. if (status == StartTaskStatus.Done || status == StartTaskStatus.UnknownError)
  385. {
  386. ReferencePool.Release(task);
  387. }
  388. current = next;
  389. }
  390. }
  391. }
  392. }