How do I invoke functions on the main thread?

Hey guys,

I created a simple class for this reason that you can call with a one-liner.

You can use it like this:

 public IEnumerator ThisWillBeExecutedOnTheMainThread() {
     Debug.Log ("This is executed from the main thread");
     yield return null;
 }
 
 public void ExampleMainThreadCall() {
     UnityMainThreadDispatcher.Instance().Enqueue(ThisWillBeExecutedOnTheMainThread());
 }

Simply head over to https://github.com/PimDeWitte/UnityMainThreadDispatcher and start using it if you'd like.

Uncomplicated and efficient:

 using System.Collections.Generic;
 using System.Threading;
 using System;
 using UnityEngine;
 
 public class Dispatcher : MonoBehaviour
 {
     public static void RunAsync(Action action) {
         ThreadPool.QueueUserWorkItem(o => action());
     }
 
     public static void RunAsync(Action<object> action, object state) {
         ThreadPool.QueueUserWorkItem(o => action(o), state);
     }
 
     public static void RunOnMainThread(Action action)
     {
         lock(_backlog) {
             _backlog.Add(action);
             _queued = true;
         }
     }
 
     [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
     private static void Initialize()
     {
         if(_instance == null) {
             _instance = new GameObject("Dispatcher").AddComponent<Dispatcher>();
             DontDestroyOnLoad(_instance.gameObject);
         }
     }
 
     private void Update()
     {
         if(_queued)
         {
             lock(_backlog) {
                 var tmp = _actions;
                 _actions = _backlog;
                 _backlog = tmp;
                 _queued = false;
             }
 
             foreach(var action in _actions)
                 action();
 
             _actions.Clear();
         }
     }
 
     static Dispatcher _instance;
     static volatile bool _queued = false;
     static List<Action> _backlog = new List<Action>(8);
     static List<Action> _actions = new List<Action>(8);
 }

You can easily create a dispatcher to talk to Unity's main loop by having a component read from a list of available actions. This Unity Gems Threading Article contains a package that can be used to achieve this.

It is used inconjunction with threads like this:

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

The download for the package is in the article. Basically using QueueOnMainThread passes the closure to be run on the main thread as soon as possible or after a specified delay.

If anyone is interested I reworked the Loom Class from @whydoidoit 's Unity Gems link to an EditorWindow. This way you can easily thread long processes without locking up the editor window.

 using UnityEngine;
 using System.Collections;
 using System.Collections.Generic;
 using UnityEditor;
 using System.Threading;
 using System;
 using System.IO;
 using System.Linq;
 
 public class LoomEditorWindow : EditorWindow {
     
     public int maxThreads = 8;
     
     private int numThreads;
     private int _count;
     
     private bool m_HasLoaded = false;
     
     private List<Action> _actions = new List<Action>();
     private List<DelayedQueueItem> _delayed = new  List<DelayedQueueItem>();
 
     private List<DelayedQueueItem> _currentDelayed = new List<DelayedQueueItem>();
     private List<Action> _currentActions = new List<Action>();
     
     public struct DelayedQueueItem
     {
         public float time;
         public Action action;
     }
     
     protected void QueueOnMainThread(Action action)
     {
         QueueOnMainThread( action, 0f);
     }
     
     protected void QueueOnMainThread(Action action, float time)
     {
         if(time != 0)
         {
             lock(_delayed)
             {
                 _delayed.Add(new DelayedQueueItem { time = Time.time + time, action = action});
             }
         }
         else
         {
             lock (_actions)
             {
                 _actions.Add(action);
             }
         }
     }
     
     protected Thread RunAsync(Action a)
     {
         while(numThreads >= maxThreads)
         {
             Thread.Sleep(1);
         }
         Interlocked.Increment(ref numThreads);
         ThreadPool.QueueUserWorkItem(RunAction, a);
         return null;
     }
     
     private void RunAction(object action)
     {
         try
         {
             ((Action)action)();
         }
         catch
         {
         }
         finally
         {
             Interlocked.Decrement(ref numThreads);
         }
     }
     
     protected virtual void Start()
     {
         m_HasLoaded = true;
         
     }
     
     protected virtual void Update()
     {
         if(m_HasLoaded == false)
             Start();
         
         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();
         }
     }
 }