【转】Unity多线程（Thread）和主线程（MainThread）交互使用类——Loom工具分享

Unity多线程（Thread）和主线程（MainThread）交互使用类——Loom工具分享

By D.S.Qiu

尊重他人的劳动，支持原创，转载请注明出处：http.dsqiu.iteye.com

          熟悉Unity的developer都知道在Unity中的线程不能使用Unity的对象，但可使用Unity的值类型变量，如Vector3等。这样就使得线程在Unity中显的很鸡肋和蹩脚，由于不少函数很都是UnityEngine类或函数的调用的，对于哪些是能够在多线程使用，风雨冲进行了以下总结：

0. 变量(都能指向相同的内存地址)都是共享的

1. 不是UnityEngine的API能在分线程运行

2. UnityEngine定义的基本结构(int,float,Struct定义的数据类型)能够在分线程计算，如 Vector3(Struct)能够 ， 但Texture2d(class,根父类为Object)不能够。

3. UnityEngine定义的基本类型的函数能够在分线程运行，如

       int i = 99;

       print (i.ToString());

       Vector3 x = new Vector3(0,0,9);

       x.Normalize();

类的函数不能在分线程运行

       obj.name 

实际是get_name函数，分线程报错误:get_name  can only be called from the main thread.

       Texture2D tt = new Texture2D(10,10);

实际会调用UnityEngine里的Internal_Create，分线程报错误:Internal_Create  can only be called from the main thread.

其余transform.position，Texture.Apply()等等都不能在分线程里运行。

 结论: 分线程能够作 基本类型的计算， 以及非Unity(包括.Net及SDK)的API。

        D.S.Qiu以为Unity作了这个限制，主要是Unity的函数执行机制是帧序列调用，甚至连Unity的协程Coroutine的执行机制都是肯定的，若是可使用多线程访问UnityEngine的对象和api就得考虑同步问题了，也就是说Unity其实根本没有多线程的机制，协程只是达到一个延时或者是当指定条件知足是才继续执行的机制。

        咱们的项目目前还有没有比较耗时的计算，因此尚未看到Thread的使用。原本一直没有太考虑着方面的事情，直到在UnityGems.com看到Loom这个类，叹为观止呀。直接贴出人家的介绍（不必翻译了  ）：

Threads on a Loom

Our class is called Loom.  Loom lets you easily run code on another thread and have that other thread run code on the main game thread when it needs to.

There are only two functions to worry about:

• RunAsync(Action) which runs a set of statements on another thread
• QueueOnMainThread(Action, [optional] float time) - which runs a set of statements on the main thread (with an optional delay).

You access Loom using Loom.Current - it deals with creating an invisible game object to interact with the games main thread.

        

        咱们只须要关系两个函数：RunAsync(Action)和QueueOnMainThread(Action, [optional] float time) 就能够轻松实现一个函数的两段代码在C#线程和Unity的主线程中交叉运行。原理也很简单：用线程池去运行RunAsync(Action)的函数，在Update中运行QueueOnMainThread(Acition, [optional] float time)传入的函数。

直接贴出源码，供拜读：

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;   }  }    void Awake()  {   _current = this;   initialized = true;  }    static bool initialized;    static void Initialize()  {   if (!initialized)   {       if(!Application.isPlaying)     return;    initialized = true;    var g = new GameObject("Loom");    _current = g.AddComponent<Loom>();   }      }    private List<Action> _actions = new List<Action>();  public struct DelayedQueueItem  {   public float time;   public Action action;  }  private List<DelayedQueueItem> _delayed = new List<DelayedQueueItem>();  List<DelayedQueueItem> _currentDelayed = new List<DelayedQueueItem>();    public static void QueueOnMainThread(Action action)  {   QueueOnMainThread( action, 0f);  }  public static void QueueOnMainThread(Action action, float time)  {   if(time != 0)   {    lock(Current._delayed)    {     Current._delayed.Add(new DelayedQueueItem { time = Time.time + time, action = action});    }   }   else   {    lock (Current._actions)    {     Current._actions.Add(action);    }   }  }    public static Thread RunAsync(Action a)  {   Initialize();   while(numThreads >= maxThreads)   {    Thread.Sleep(1);   }   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<Action> _currentActions = new List<Action>();    // Update is called once per frame  void Update()  {   lock (_actions)   {    _currentActions.Clear();    _currentActions.AddRange(_actions);    _actions.Clear();   }   foreach(var a in _currentActions)   {    a();   }   lock(_delayed)   {    _currentDelayed.Clear();    _currentDelayed.AddRange(_delayed.Where(d=>d.time <= Time.time));    foreach(var item in _currentDelayed)     _delayed.Remove(item);   }   foreach(var delayed in _currentDelayed)   {    delayed.action();   }           }
}

       怎么实现一个函数内使用多线程计算又保持函数体内代码的顺序执行，印象中使用多线程就是要摆脱代码块的顺序执行，但这里是把本来一个函数分拆成为两部分：一部分在C#线程中使用，另外一部仍是得在Unity的MainThread中使用，怎么解决呢，还得看例子：

//Scale a mesh on a second thread void ScaleMesh(Mesh mesh, float scale)
{  //Get the vertices of a mesh  var vertices = mesh.vertices;  //Run the action on a new thread  Loom.RunAsync(()=>{   //Loop through the vertices   for(var i = 0; i < vertices.Length; i++)   {    //Scale the vertex    vertices[i] = vertices[i] * scale;   }   //Run some code on the main thread   //to update the mesh   Loom.QueueOnMainThread(()=>{    //Set the vertices    mesh.vertices = vertices;    //Recalculate the bounds    mesh.RecalculateBounds();   });  });
}

        这个例子是对Mesh的顶点进行放缩，同时也是一个使用闭包（closure）和lambda表达式的一个很好例子。看完例子，是否是颇有把项目中一些耗时的函数给拆分出来，D.S.Qiu就想用这个方法来改进下NGUI的底层机制（看下性能不能改进）。

小结：

       D.S.Qiu在编程技术掌握仍是一个菜鸟，Thread仍是停留在实现Runable接口或继承Thread的一个水平上，对多线程编程的认识还只是九牛一毛。原本我觉得Loom的实现会比较复杂，当我发现只有100多行的代码是大为惊叹，这也得益于如今语言的改进，至少从语言使用的便利性上仍是有很大的进步的。

       有了Loom这个工具类，在不少涉及UnityEngine对象的耗时计算仍是能够获得一个解决方法的：

               如在场景中用A*算法进行大量的数据计算

               变形网格中操做大量的顶点 
               持续的要运行上传数据到服务器 
               二维码识别等图像处理

        Loom简单而又巧妙，佩服Loom的做者。

        若是您对D.S.Qiu有任何建议或意见能够在文章后面评论，或者发邮件（gd.s.qiu@gmail.com)交流，您的鼓励和支持是我前进的动力，但愿能有更多更好的分享。