Unity-线程工具（五）

最新推荐文章于 2024-09-13 20:52:21 发布
Data菌
最新推荐文章于 2024-09-13 20:52:21 发布
阅读量434
点赞数
分类专栏： C# Unity 文章标签： Unity 多线程协程管理控制异步
本文链接：https://blog.csdn.net/wlqchengzhangji/article/details/118017830
版权
Unity 同时被 2 个专栏收录
190 篇文章 29 订阅
订阅专栏
40 篇文章 3 订阅
订阅专栏
上篇介绍了ThreadWaitHelper类，ThreadManager.cs：游戏项目多线程管理控制器，其他外界模块系统，只需要通过该控制器开启线程执行任务函数。
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Threading;
/*
 * Author:W
 * 线程管理器
 * 1）主线程操作
 * 2）非主线程操作
 */
namespace W.GameFramework.MultiThread
{
	public class ThreadManager:MonoBehaviour
	{
		/// <summary>
		/// 开启协程，间隔多少秒检测是否有待处理主线程任务，如果有则将它们执行
		/// </summary>
		private float WaitForSecondsTime = 0.005f;

		#region 单例
		private static ThreadManager instance;
		/// <summary>
		/// 非主线程工具单例
		/// </summary>
		public static ThreadManager Instance
		{
			get
			{
				if (instance == null)
				{
					GameObject ThreadManagerObj = new GameObject("ThreadManager");
					instance = ThreadManagerObj.AddComponent<ThreadManager>();
					GameObject.DontDestroyOnLoad(ThreadManagerObj);

					UnityAppMonitor.Instance.Init();

					MainThreadHelper.Init();					

					SingleThreadHelper.Init();

				}

				return instance;
			}
		}

		void Awake()
		{
			if (instance != null)
			{
				GameObject.Destroy(this.gameObject);
			}
			else
			{
				InvokeRepeating("DealMainThreadTasks", WaitForSecondsTime, WaitForSecondsTime);
			}
		}

		/// <summary>
		/// 初始化
		/// </summary>
		public void Init()
		{

		}
        #endregion


        #region 独立线程执行任务
        /// <summary>
        /// 使用独立线程处理任务
        /// 【不带参数】
        /// </summary>
        /// <param name="threadStart"></param>
        /// <param name="priority"></param>
        /// <returns></returns>
        public Thread DealTaskBySingleThread(ThreadStart threadStart, System.Threading.ThreadPriority priority = System.Threading.ThreadPriority.Normal)
		{
			return SingleThreadHelper.DealTaskBySingleThread(threadStart,priority);
		}

		/// <summary>
		/// 使用独立线程处理任务
		/// 【带参数】
		/// </summary>
		/// <param name="threadStart"></param>
		/// <param name="arg"></param>
		/// <param name="priority"></param>
		/// <returns></returns>
		public Thread DealTaskBySingleThread(ParameterizedThreadStart threadStart, object arg, System.Threading.ThreadPriority priority = System.Threading.ThreadPriority.Normal)
		{
			return SingleThreadHelper.DealTaskBySingleThread(threadStart,arg,priority);
		}

		#endregion


		#region 使用线程池处理多任务
		/// <summary>
		/// 使用线程池来处理多任务
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="taskExecutor"></param>
		/// <param name="taskArr"></param>
		/// <param name="onComplete"></param>
		/// <param name="onTaskDataComplete"></param>
		/// <param name="maxThreads"></param>
		/// <param name="ForceToMainThread"></param>
		/// <returns></returns>
		public ThreadPoolHelper DealMultiThreadedTaskExecution<T>(ThreadTaskExecutor<T> taskExecutor, T[] taskArr, MultiThreadedTaskComplete<T> onComplete, MultiThreadedTaskDataComplete<T> onTaskDataComplete, int maxThreads = -1,ThreadPoolHelper threadPoolHelper = null,bool ForceToMainThread = false)
		{
			return MultiThreadedTaskLoadHelper.DealMultiThreadTaskLoadExcution<ThreadTaskExecutor<T>, T>(taskExecutor, taskArr, null, onComplete, onTaskDataComplete, maxThreads,threadPoolHelper,ForceToMainThread);
		}

		/// <summary>
		/// 使用线程池来处理多任务
		/// 【带任务索引】
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="taskExecutor"></param>
		/// <param name="taskArr"></param>
		/// <param name="onComplete"></param>
		/// <param name="onTaskDataComplete"></param>
		/// <param name="maxThreads"></param>
		/// <param name="ForceToMainThread"></param>
		/// <returns></returns>
		public ThreadPoolHelper DealMultiThreadedTaskExecution<T>(ThreadTaskExecutorIndexed<T> taskExecutor, T[] taskArr, MultiThreadedTaskComplete<T> onComplete, MultiThreadedTaskDataComplete<T> onTaskDataComplete, int maxThreads = -1, ThreadPoolHelper threadPoolHelper = null, bool ForceToMainThread = false)
		{
			return MultiThreadedTaskLoadHelper.DealMultiThreadTaskLoadExcution<ThreadTaskExecutorIndexed<T>, T>(taskExecutor, taskArr, null, onComplete, onTaskDataComplete, maxThreads,threadPoolHelper,ForceToMainThread);
		}

		/// <summary>
		/// 使用线程池来处理多任务
		/// 【带任务参数】
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="taskExecutor"></param>
		/// <param name="taskArr"></param>
		/// <param name="onComplete"></param>
		/// <param name="onTaskDataComplete"></param>
		/// <param name="maxThreads"></param>
		/// <param name="ForceToMainThread"></param>
		/// <returns></returns>
		public ThreadPoolHelper DealMultiThreadedTaskExecution<T>(ThreadTaskExecutorArg<T> taskExecutor, T[] taskArr,object arg, MultiThreadedTaskComplete<T> onComplete, MultiThreadedTaskDataComplete<T> onTaskDataComplete, int maxThreads = -1, ThreadPoolHelper threadPoolHelper = null, bool ForceToMainThread = false)
		{
			return MultiThreadedTaskLoadHelper.DealMultiThreadTaskLoadExcution<ThreadTaskExecutorArg<T>, T>(taskExecutor, taskArr, arg, onComplete, onTaskDataComplete, maxThreads, threadPoolHelper, ForceToMainThread);
		}


		/// <summary>
		/// 使用线程池来处理多任务
		/// 【带任务索引和参数】
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="taskExecutor"></param>
		/// <param name="taskArr"></param>
		/// <param name="onComplete"></param>
		/// <param name="onTaskDataComplete"></param>
		/// <param name="maxThreads"></param>
		/// <param name="ForceToMainThread"></param>
		/// <returns></returns>
		public ThreadPoolHelper DealMultiThreadedTaskExecution<T>(ThreadTaskExecutorArgIndexed<T> taskExecutor, T[] taskArr, object arg, MultiThreadedTaskComplete<T> onComplete, MultiThreadedTaskDataComplete<T> onTaskDataComplete, int maxThreads = -1, ThreadPoolHelper threadPoolHelper = null, bool ForceToMainThread = false)
		{
			return MultiThreadedTaskLoadHelper.DealMultiThreadTaskLoadExcution<ThreadTaskExecutorArgIndexed<T>, T>(taskExecutor, taskArr, arg, onComplete, onTaskDataComplete, maxThreads,threadPoolHelper,ForceToMainThread);
		}
        #endregion


        #region 使用主线程执行任务
        /// <summary>
        /// 让主线程来执行任务
        /// </summary>
        /// <param name="mainThreadHandler"></param>
        /// <param name="waitForExecution"></param>
        public void DealTaskByMainThread(MainThreadHandler mainThreadHandler, bool waitForExecution = false)
		{
			MainThreadHelper.DealTaskByMainThread(mainThreadHandler,waitForExecution);
		}

		/// <summary>
		/// 使用主线程来执行任务
		/// 【带参数】
		/// </summary>
		/// <param name="threadHandlerWithArg"></param>
		/// <param name="arg"></param>
		/// <param name="waitForExecution"></param>
		public void DealTaskWithArgByMainThread(MainThreadHandlerWithArg threadHandlerWithArg,object arg, bool waitForExecution = false)
		{
			MainThreadHelper.DealTaskWithArgByMainThread(threadHandlerWithArg,arg,waitForExecution);
		}

		/// <summary>
		/// 让主线程执行任务
		/// 【有返回值】
		/// </summary>
		/// <param name="mainThreadHandlerWithReturn"></param>
		/// <returns></returns>
		public object DealTaskWithReturnByMainThread(MainThreadHandlerWithReturn mainThreadHandlerWithReturn)
		{
			return MainThreadHelper.DealTaskWithReturnByMainThread(mainThreadHandlerWithReturn);
		}


		/// <summary>
		/// 让主线程执行该任务
		/// 【带参数，也有返回值】
		/// </summary>
		/// <param name="mainThreadHandlerWithArgAndReturn"></param>
		/// <param name="arg"></param>
		/// <returns></returns>
		public object DealTaskWithArgAndReturnByMainThread(MainThreadHandlerWithArgAndReturn mainThreadHandlerWithArgAndReturn,object arg)
		{
			return MainThreadHelper.DealTaskWithArgAndReturnByMainThread(mainThreadHandlerWithArgAndReturn,arg);
		}
        #endregion


        #region 线程休眠
        /// <summary>
        /// 让当前线程休眠特定帧数
        /// </summary>
        /// <param name="waitFrames"></param>
        public void WaitForNextFrame(int waitFrames = 1)
		{
			ThreadWaitHelper.WaitForNextFrame(waitFrames);
		}

		/// <summary>
		/// 让当前线程休眠特定秒数
		/// </summary>
		/// <param name="seconds"></param>
		public void WaitForSeconds(float seconds)
		{
			ThreadWaitHelper.WaitForSeconds(seconds);
		}
        #endregion


        #region 当前帧
        private int curFrame = 0;
		/// <summary>
		/// 当前帧
		/// </summary>
		public  int CurFrame
		{
			get { return curFrame; }
		}

		public void Update()
		{
			curFrame = Time.frameCount;

			DealMainThreadTasks();
		}
		#endregion


		/// <summary>
		/// 新建多线程调度对象
		/// </summary>
		/// <returns></returns>
		public  ThreadPoolHelper CreateThreadPoolHelper()
		{
			GameObject go = new GameObject("ThreadPoolHelper");
			return go.AddComponent<ThreadPoolHelper>();
		}

		/// <summary>
		/// 检查如果游戏App不处于活跃状态并且也不是主线程，则间歇性休眠或者停止当前线程
		/// </summary>
		public void SleepOrAbortIfUnityInactive()
		{			
			while (!UnityAppMonitor.Instance.Active && !MainThreadHelper.CheckIsMainThread())
			{
				if (UnityAppMonitor.Instance.Running)
				{					
					Thread.Sleep(100);
				}
				else
				{					
					Thread.CurrentThread.Interrupt();
					Thread.CurrentThread.Join();
				}
			}
		}

		
		/// <summary>
		/// 定期检查处理主线程的缓存的任务
		/// </summary>
		private void DealMainThreadTasks()
		{
			MainThreadHelper.DealWithTasks();
		}


        void OnApplicationQuit()
		{
			SingleThreadHelper.AbortRunningThreads();
		}
	}
}
下篇文章链接点击进入