Unity自定义定时器，模拟协程，脱离MonoBehavior控制

 using System;
 using System.Collections.Generic;
 using System.Timers;

 public class PETimer {
     private Action<string> taskLog;

     private static readonly string lockTid = "lockTid";
     private DateTime startDateTime = new DateTime(, , , , , , );
     private double nowTime;

     private int tid;
     private List<int> tidLst = new List<int>();
     private List<int> recTidLst = new List<int>();

     private static readonly string lockTime = "lockTime";
     private List<PETimeTask> tmpTimeLst = new List<PETimeTask>();
     private List<PETimeTask> taskTimeLst = new List<PETimeTask>();
     private List<int> tmpDelTimeLst = new List<int>();

     private int frameCounter;
     private static readonly string lockFrame = "lockFrame";
     private List<PEFrameTask> tmpFrameLst = new List<PEFrameTask>();
     private List<PEFrameTask> taskFrameLst = new List<PEFrameTask>();
     private List<int> tmpDelFrameLst = new List<int>();

     public PETimer(int interval = ) {
         tidLst.Clear();
         recTidLst.Clear();

         tmpTimeLst.Clear();
         taskTimeLst.Clear();

         tmpFrameLst.Clear();
         taskFrameLst.Clear();
     }

     public void Update() {
         CheckTimeTask();
         CheckFrameTask();

         DelTimeTask();
         DelFrameTask();

         if (recTidLst.Count > ) {
             lock (lockTid) {
                 RecycleTid();
             }
         }
     }
     private void DelTimeTask() {
         if (tmpDelTimeLst.Count > ) {
             lock (lockTime) {
                 for (int i = ; i < tmpDelTimeLst.Count; i++) {
                     bool isDel = false;
                     int delTid = tmpDelTimeLst[i];
                     for (int j = ; j < taskTimeLst.Count; j++) {
                         PETimeTask task = taskTimeLst[j];
                         if (task.tid == delTid) {
                             isDel = true;
                             taskTimeLst.RemoveAt(j);
                             recTidLst.Add(delTid);
                             //LogInfo("Del taskTimeLst ID:" + System.Threading.Thread.CurrentThread.ManagedThreadId.ToString());
                             break;
                         }
                     }

                     if (isDel)
                         continue;

                     for (int j = ; j < tmpTimeLst.Count; j++) {
                         PETimeTask task = tmpTimeLst[j];
                         if (task.tid == delTid) {
                             tmpTimeLst.RemoveAt(j);
                             recTidLst.Add(delTid);
                             //LogInfo("Del tmpTimeLst ID:" + System.Threading.Thread.CurrentThread.ManagedThreadId.ToString());
                             break;
                         }
                     }
                 }
             }
         }
     }
     private void DelFrameTask() {
         if (tmpDelFrameLst.Count > ) {
             lock (lockFrame) {
                 for (int i = ; i < tmpDelFrameLst.Count; i++) {
                     bool isDel = false;
                     int delTid = tmpDelFrameLst[i];
                     for (int j = ; j < taskFrameLst.Count; j++) {
                         PEFrameTask task = taskFrameLst[j];
                         if (task.tid == delTid) {
                             isDel = true;
                             taskFrameLst.RemoveAt(j);
                             recTidLst.Add(delTid);
                             break;
                         }
                     }

                     if (isDel)
                         continue;

                     for (int j = ; j < tmpFrameLst.Count; j++) {
                         PEFrameTask task = tmpFrameLst[j];
                         if (task.tid == delTid) {
                             tmpFrameLst.RemoveAt(j);
                             recTidLst.Add(delTid);
                             break;
                         }
                     }
                 }
             }
         }
     }
     private void CheckTimeTask() {
         if (tmpTimeLst.Count > ) {
             lock (lockTime) {
                 //加入缓存区中的定时任务
                 for (int tmpIndex = ; tmpIndex < tmpTimeLst.Count; tmpIndex++) {
                     taskTimeLst.Add(tmpTimeLst[tmpIndex]);
                 }
                 tmpTimeLst.Clear();
             }
         }

         //遍历检测任务是否达到条件
         nowTime = GetUTCMilliseconds();
         for (int index = ; index < taskTimeLst.Count; index++) {
             PETimeTask task = taskTimeLst[index];
             if (nowTime.CompareTo(task.destTime) < ) {
                 continue;
             }
             else {
                 Action cb = task.callback;
                 try {
                     if (cb != null) {
                         cb();
                     }

                 }
                 catch (Exception e) {
                     LogInfo(e.ToString());
                 }

                 //移除已经完成的任务
                 if (task.count == ) {
                     taskTimeLst.RemoveAt(index);
                     index--;
                     recTidLst.Add(task.tid);
                 }
                 else {
                     if (task.count != ) {
                         task.count -= ;
                     }
                     task.destTime += task.delay;
                 }
             }
         }
     }
     private void CheckFrameTask() {
         if (tmpFrameLst.Count > ) {
             lock (lockFrame) {
                 //加入缓存区中的定时任务
                 for (int tmpIndex = ; tmpIndex < tmpFrameLst.Count; tmpIndex++) {
                     taskFrameLst.Add(tmpFrameLst[tmpIndex]);
                 }
                 tmpFrameLst.Clear();
             }
         }

         frameCounter += ;
         //遍历检测任务是否达到条件
         for (int index = ; index < taskFrameLst.Count; index++) {
             PEFrameTask task = taskFrameLst[index];
             if (frameCounter < task.destFrame) {
                 continue;
             }
             else {
                 Action cb = task.callback;
                 try {
                     if (cb != null) {
                         cb();
                     }
                 }
                 catch (Exception e) {
                     LogInfo(e.ToString());
                 }

                 //移除已经完成的任务
                 if (task.count == ) {
                     taskFrameLst.RemoveAt(index);
                     index--;
                     recTidLst.Add(task.tid);
                 }
                 else {
                     if (task.count != ) {
                         task.count -= ;
                     }
                     task.destFrame += task.delay;
                 }
             }
         }
     }

     #region TimeTask
     public int AddTimeTask(Action callback, double delay, PETimeUnit timeUnit = PETimeUnit.Millisecond, int count = ) {
         if (timeUnit != PETimeUnit.Millisecond) {
             switch (timeUnit) {
                 case PETimeUnit.Second:
                     delay = delay * ;
                     break;
                 case PETimeUnit.Minute:
                     delay = delay *  * ;
                     break;
                 case PETimeUnit.Hour:
                     delay = delay *  *  * ;
                     break;
                 case PETimeUnit.Day:
                     delay = delay *  *  *  * ;
                     break;
                 default:
                     LogInfo("Add Task TimeUnit Type Error...");
                     break;
             }
         }
         int tid = GetTid(); ;
         nowTime = GetUTCMilliseconds();
         lock (lockTime) {
             tmpTimeLst.Add(new PETimeTask(tid, callback, nowTime + delay, delay, count));
         }
         return tid;
     }
     public void DeleteTimeTask(int tid) {
         lock (lockTime) {
             tmpDelTimeLst.Add(tid);
             //LogInfo("TmpDel ID:" + System.Threading.Thread.CurrentThread.ManagedThreadId.ToString());
         }

     }
     public bool ReplaceTimeTask(int tid, Action callback, float delay, PETimeUnit timeUnit = PETimeUnit.Millisecond, int count = ) {
         if (timeUnit != PETimeUnit.Millisecond) {
             switch (timeUnit) {
                 case PETimeUnit.Second:
                     delay = delay * ;
                     break;
                 case PETimeUnit.Minute:
                     delay = delay *  * ;
                     break;
                 case PETimeUnit.Hour:
                     delay = delay *  *  * ;
                     break;
                 case PETimeUnit.Day:
                     delay = delay *  *  *  * ;
                     break;
                 default:
                     LogInfo("Replace Task TimeUnit Type Error...");
                     break;
             }
         }
         nowTime = GetUTCMilliseconds();
         PETimeTask newTask = new PETimeTask(tid, callback, nowTime + delay, delay, count);

         bool isRep = false;
         for (int i = ; i < taskTimeLst.Count; i++) {
             if (taskTimeLst[i].tid == tid) {
                 taskTimeLst[i] = newTask;
                 isRep = true;
                 break;
             }
         }

         if (!isRep) {
             for (int i = ; i < tmpTimeLst.Count; i++) {
                 if (tmpTimeLst[i].tid == tid) {
                     tmpTimeLst[i] = newTask;
                     isRep = true;
                     break;
                 }
             }
         }

         return isRep;
     }
     #endregion

     #region FrameTask
     public int AddFrameTask(Action callback, int delay, int count = ) {
         int tid = GetTid();
         lock (lockTime) {
             tmpFrameLst.Add(new PEFrameTask(tid, callback, frameCounter + delay, delay, count));
         }
         return tid;
     }
     public void DeleteFrameTask(int tid) {
         lock (lockFrame) {
             tmpDelFrameLst.Add(tid);
         }
     }
     public bool ReplaceFrameTask(int tid, Action callback, int delay, int count = ) {
         PEFrameTask newTask = new PEFrameTask(tid, callback, frameCounter + delay, delay, count);

         bool isRep = false;
         for (int i = ; i < taskFrameLst.Count; i++) {
             if (taskFrameLst[i].tid == tid) {
                 taskFrameLst[i] = newTask;
                 isRep = true;
                 break;
             }
         }

         if (!isRep) {
             for (int i = ; i < tmpFrameLst.Count; i++) {
                 if (tmpFrameLst[i].tid == tid) {
                     tmpFrameLst[i] = newTask;
                     isRep = true;
                     break;
                 }
             }
         }

         return isRep;
     }
     #endregion
     public void SetLog(Action<string> handle)
     {
         taskLog = handle;
     }

     public void Reset() {
         tid = ;
         tidLst.Clear();
         recTidLst.Clear();

         tmpTimeLst.Clear();
         taskTimeLst.Clear();

         tmpFrameLst.Clear();
         taskFrameLst.Clear();

         taskLog = null;
     }

     #region Tool Methonds
     private int GetTid() {
         lock (lockTid) {
             tid += ;

             //安全代码，以防万一
             while (true) {
                 if (tid == int.MaxValue) {
                     tid = ;
                 }

                 bool used = false;
                 for (int i = ; i < tidLst.Count; i++) {
                     if (tid == tidLst[i]) {
                         used = true;
                         break;
                     }
                 }
                 if (!used) {
                     tidLst.Add(tid);
                     break;
                 }
                 else {
                     tid += ;
                 }
             }
         }

         return tid;
     }
     private void RecycleTid() {
         for (int i = ; i < recTidLst.Count; i++) {
             int tid = recTidLst[i];

             for (int j = ; j < tidLst.Count; j++) {
                 if (tidLst[j] == tid) {
                     tidLst.RemoveAt(j);
                     break;
                 }
             }
         }
         recTidLst.Clear();
     }
     private void LogInfo(string info) {
         if (taskLog != null) {
             taskLog(info);
         }
     }
     private double GetUTCMilliseconds() {
         TimeSpan ts = DateTime.UtcNow - startDateTime;
         return ts.TotalMilliseconds;
     }
     #endregion

 }

 class PETimeTask
 {
     public int tid;
     public Action callback;
     public double destTime;//单位：毫秒
     public double delay;
     public int count;

     public PETimeTask(int tid, Action callback, double destTime, double delay, int count)
     {
         this.tid = tid;
         this.callback = callback;
         this.destTime = destTime;
         this.delay = delay;
         this.count = count;
     }
 }

 class PEFrameTask
 {
     public int tid;
     public Action callback;
     public int destFrame;
     public int delay;
     public int count;

     public PEFrameTask(int tid, Action callback, int destFrame, int delay, int count)
     {
         this.tid = tid;
         this.callback = callback;
         this.destFrame = destFrame;
         this.delay = delay;
         this.count = count;
     }
 }

 public enum PETimeUnit {
     Millisecond,
     Second,
     Minute,
     Hour,
     Day
 }

使用方法：

 //实例化计时类
 PETimer pt = new PETimer();
 //时间定时任务
 pt.AddTimeTask(TimerTask, , PETimeUnit.Millisecond, );
 //帧数定时任务
 pt.AddFrameTask(FrameTask, , );

 int tempID = pt.AddTimeTask(() => {
     Debug.Log("定时等待替换......");
 }, , PETimeUnit.Second, );

 //定时任务替换
 pt.ReplaceTimeTask(tempID, () => {
     Debug.Log("定时任务替换完成......");
 }, , PETimeUnit.Second, );

 //定时任务删除
 pt.DeleteTimeTask(tempID);

 //定时检测与处理由MonoBehaviour中的Update()函数来驱动
 void Update() {
     pt.Update();
 }

转自https://github.com/PlaneZhong/PETimer