Unity主线程和子线程跳转调用（2)

　　在上一篇介绍了多线程和Unity交互方式，但是由于我的项目是一个unity编辑器插件项目，很显然上一篇的代码需要加以修改，在编辑器下实现Loom.

　　1，Editor下的没有Update这个生命周期函数，但是Ediitor提供了EditorApplication.update这个事件，自己用这个事件订阅update方法即可

　　2，Editor下的没有Awake OnDestory这些生命周期函数，需要自己编写方法让外部去创建、销毁Loom

　　3,  我的项目需要保证子线程逻辑不假死的同时又要保证同步，如下面这段伪代码，执行顺序为：DownFile1->UnityFunction1->DownFile2->UnityFunction2

　　

Function
{
    //异步在多线程下运行
    Loom.RunAsync(() =>
    {
        //耗时函数
        DownFile1();

        //回到unity线程继续运行
        Loom.QueueOnMainThread(()=>
        {
            //这个函数是unity函数
            UnityFunction1();
        }

        //耗时函数
        DownFile2();
         //回到unity线程继续运行
        Loom.QueueOnMainThread(()=>
        {
            //这个函数是unity函数
            UnityFunction2();
        }

    }
}

　　

　　修改后的代码如下

 using UnityEngine;
 using System.Collections;
 using System.Collections.Generic;
 using System;
 using System.Threading;
 using System.Linq;
 using UnityEditor;
 public class Loom
 {
     /// <summary>
     /// 当前是否有unity任务需要执行
     /// </summary>
     static bool hasUnityAction = true;

     private static Thread loomThread;

     /// <summary>
     /// unity任务表
     /// </summary>
     private List<Action> actions = new List<Action>();

     #region 单例 注册update事件
     private static Loom _instance;
     private static readonly object lockObj = new object();
     public static Loom Current
     {
         get
         {
             if (_instance == null)
             {
                 lock (lockObj)
                 {
                     if (_instance == null)
                     {
                         _instance = new Loom();
                     }

                 }
             }
             return _instance;
         }
     }
     private Loom()
     {
         EditorApplication.update += Update;

     }
     #endregion

     /// <summary>
     /// 子线程启动一个任务
     /// </summary>
     /// <param name="a"></param>
     /// <returns></returns>
     public Thread RunAsync(Action a)
     {
         if (loomThread != null)
         {
             Stop();
             throw new Exception("任务仅运行一次");
         }
         loomThread = new Thread(new ParameterizedThreadStart(RunAction));
         loomThread.Name = "Loom线程";
         loomThread.Priority = System.Threading.ThreadPriority.Lowest;
         loomThread.Start(a);
         return loomThread;
     }
     /// <summary>
     /// 加入一个任务到主线程队列
     /// </summary>
     /// <param name="action"></param>
     public void QueueOnMainThread(Action action)
     {
         if (Current != null && Thread.CurrentThread == loomThread)
         {
             hasUnityAction = true;
             lock (Current.actions)
             {
                 Current.actions.Add(action);
             }
             while (hasUnityAction)
             {
                 loomThread.Priority = System.Threading.ThreadPriority.Lowest;
                 Thread.Sleep();
             }
         }

     }

     /// <summary>
     /// 延迟子线程
     /// </summary>
     /// <param name="time"></param>
     public void Sleep(int time)
     {
         if (Current != null && Thread.CurrentThread == loomThread)
         {
             Thread.Sleep(time);

         }
     }

     /// <summary>
     /// 停止任务
     /// </summary>
     public void Stop()
     {
         EditorApplication.update -= Update;
         try
         {
             loomThread.Abort();
         }
         catch (Exception e)
         {
             Debug.Log(e.ToString());
         }
         finally
         {
             loomThread = null;
             _instance = null;
         }

     }

     private void RunAction(object action)
     {
         try
         {
             ((Action)action)();
         }
         catch
         {
         }

     }

     List<Action> _currentActions = new List<Action>();

     static void Update()
     {
         try
         {

             if (!hasUnityAction) return;

             lock (Current.actions)
             {
                 Current._currentActions.Clear();
                 Current._currentActions.AddRange(Current.actions);
                 Current.actions.Clear();
             }
             for (int i = ; i < Current._currentActions.Count; i++)
             {
                 Debug.LogError("主线程任务");
                 Current._currentActions[i]();

             }
             hasUnityAction = false;
         }
         catch
         {
             Debug.LogError("主线程任务失败");
         }
     }
 }