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(10);
            }
        }

    }

    /// <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 = 0; i < Current._currentActions.Count; i++)
            {
                Debug.LogError("主線程任務");
                Current._currentActions[i]();

            }
            hasUnityAction = false;
        }
        catch
        {
            Debug.LogError("主線程任務失敗");
        }
    }
}