unity+Loom實作多線程（Thread）和主線程（MainThread）互動

最近在做資源更新時，需要顯示現在的進度調。我在Unity中開啟了一個線程來做下載下傳任務，然後實時重新整理下載下傳進度。然後Unity報了一個錯誤。

get_isActiveAndEnabled can only be called from the main thread.

意思是Unity中的元件隻能運作在Unity的主線程中，無法在新開的線程中調用Unity的元件。

用Loom實作多線程與主線程互動

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System;
using System.Threading;
using System.Linq;

    public class Loom :MonoBehaviour
    {
        public static int maxThreads = 8;
        static int numThreads;

        private static Loom _current;
        //private int _count;
        public static Loom Current
        {
            get
            {
                Initialize();
                return _current;
            }
        }

        //用于初始化一次，在程式入口調用一次
       public void StartUp()
       {}

        static bool initialized;

        public static void Initialize()
        {
            if (!initialized)
            {

                if (!Application.isPlaying)
                    return;
                initialized = true;
                var g = new GameObject("Loom");
                _current = g.AddComponent<Loom>();
#if !ARTIST_BUILD
                UnityEngine.Object.DontDestroyOnLoad(g);
#endif
            }

        }
        public struct NoDelayedQueueItem
        {
            public Action<object> action;
            public object param;
        }

        private List<NoDelayedQueueItem> _actions = new List<NoDelayedQueueItem>();
        public struct DelayedQueueItem
        {
            public float time;
            public Action<object> action;
            public object param;
        }
        private List<DelayedQueueItem> _delayed = new List<DelayedQueueItem>();

        List<DelayedQueueItem> _currentDelayed = new List<DelayedQueueItem>();

        public static void QueueOnMainThread(Action<object> taction, object tparam)
        {
            QueueOnMainThread(taction, tparam, 0f);
        }
        public static void QueueOnMainThread(Action<object> taction, object tparam, float time)
        {
            if (time != 0)
            {
                lock (Current._delayed)
                {
                    Current._delayed.Add(new DelayedQueueItem { time = Time.time + time, action = taction, param = tparam });
                }
            }
            else
            {
                lock (Current._actions)
                {
                    Current._actions.Add(new NoDelayedQueueItem { action = taction, param = tparam });
                }
            }
        }

        public static Thread RunAsync(Action a)
        {
            Initialize();
            while (numThreads >= maxThreads)
            {
                Thread.Sleep(100);
            }
            Interlocked.Increment(ref numThreads);
            ThreadPool.QueueUserWorkItem(RunAction, a);
            return null;
        }

        private static void RunAction(object action)
        {
            try
            {
                ((Action)action)();
            }
            catch
            {
            }
            finally
            {
                Interlocked.Decrement(ref numThreads);
            }

        }


        void OnDisable()
        {
            if (_current == this)
            {

                _current = null;
            }
        }



        // Use this for initialization
        void Start()
        {

        }

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

        // Update is called once per frame
        void Update()
        {
            if (_actions.Count > 0)
            {
                lock (_actions)
                {
                    _currentActions.Clear();
                    _currentActions.AddRange(_actions);
                    _actions.Clear();
                }
                for (int i = 0; i < _currentActions.Count; i++)
                {
                    _currentActions[i].action(_currentActions[i].param);
                }
            }

            if (_delayed.Count > 0)
            {
                lock (_delayed)
                {
                    _currentDelayed.Clear();
                    _currentDelayed.AddRange(_delayed.Where(d => d.time <= Time.time));
                    for (int i = 0; i < _currentDelayed.Count; i++)
                    {
                        _delayed.Remove(_currentDelayed[i]);
                    }
                }

                for (int i = 0; i < _currentDelayed.Count; i++)
                {
                    _currentDelayed[i].action(_currentDelayed[i].param);
                }
            }
        }
    }      

public Text mText;
    void Start () 
    {
        Thread thread = new Thread(RefreshText);
        thread.Start();
    }
    
    void Update () 
    {
    
    }
    private void RefreshText()
    {
        mText.text = "Hello Loom!";
    }      

using UnityEngine;
using System.Collections;
using UnityEngine.UI;
using System.Threading;
public class testLoom : MonoBehaviour
{

    public Text mText;
    void Start () 
    {
        Loom.Current.StartUp();
        // 用Loom的方法調用一個線程
        Loom.RunAsync(
            () =>
            {
                Thread thread = new Thread(RefreshText);
                thread.Start();
            }
            );
    }
    
    void Update () 
    {
    
    }
    private void RefreshText()
    {  
        // 用Loom的方法在Unity主線程中調用Text元件
        Loom.QueueOnMainThread((param) =>
            {
                mText.text = "Hello Loom!";
            },null);
    }
}