Unity主线程和子线程跳转调用（1）

　　Unity除了一些基本的数据类型，几乎所有的API都不能在非unity线程中调用，如果项目中有一段很耗时操作，unity可能会出现“假死”。如果这段操作是和unity无关的，我们可以把这个耗时的操作放到子线程中去运行，防止unity假死提高性能，如下面这个伪代码

Function
{
    //这个函数会进行大量文件读写操作
    LoadLocalFile();

    //这个函数是unity函数
    UnityFunction();
}

　　必须保证LoadLocalFile() 不“假死”。怎么做呢？只要把Function放到多线程中，UnityFunction()回到主线程即可

　　网上的做法一般都是借鉴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 = ;
         static int numThreads;

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

         void Awake()
         {
             _current = this;
             initialized = true;
         }

         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 != )
             {
                 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();
             }
             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 > )
             {
                 lock (_actions)
                 {
                     _currentActions.Clear();
                     _currentActions.AddRange(_actions);
                     _actions.Clear();
                 }
                 for (int i = ; i < _currentActions.Count; i++)
                 {
                     _currentActions[i].action(_currentActions[i].param);
                 }
             }

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

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

使用方式

Function
{
//异步在多线程下运行
Loom.RunAsync(() =>
    {
        //这个函数会进行大量文件读写操作
        LoadLocalFile();

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

这个Loom类的大概思路就是把整个代码块放多线程中，并把需要在主线程运行的代码按委托的方式封装起来保存的list里，Updata函数是unity函数，他会自动每帧执行一次。所以他可以判断list是否有任务并执行任务，从而实现了回到主线程