Thread Ninja说明:
Thread Ninja - Multithread Coroutine
Requires Unity 3.4.0 or higher.
A simple script helps you write multithread coroutines.
Unity's coroutine is great, but it's not a real thread. And a background thread is not allowed to access Unity's API.
Thread Ninja combines coroutine & background thread, make a method both a coroutine and a background thread, makes your life easy with multithread programming.
对于yield语句不涉在try...catch中的情况:
// Use this for initialization
void Start ()
{
GotoState(RunningBaseState.time);
this.StartCoroutineAsync(AsyncCoroutine());
} IEnumerator AsyncCoroutine()
{
while (true)
{
try
{
File.OpenRead("NotExist");
}
catch (Exception e)
{
ZSLoger.Instance.Loger.Debug(e.Message);
}
Thread.Sleep();
yield return ZS.JumpToUnity;
ZSLoger.Instance.Loger.Debug("Jump 2 unity in AsyncCoroutine.");
yield return ZS.JumpBack;
}
}
输出结果:
因为yield语句不能在try...catch中的情况修改Task.cs:
using UnityEngine;
using System.Collections;
using System.Threading; namespace ZSThread
{
/// <summary>
/// Represents an async task.
/// </summary>
public class Task : IEnumerator
{
// implements IEnumerator to make it usable by StartCoroutine;
#region IEnumerator Interface
/// <summary>
/// The current iterator yield return value.
/// </summary>
public object Current { get; private set; } /// <summary>
/// Runs next iteration.
/// </summary>
/// <returns><code>true</code> for continue, otherwise <code>false</code>.</returns>
public bool MoveNext()
{
return OnMoveNext();
} public void Reset()
{
// Reset method not supported by iterator;
throw new System.NotSupportedException(
"Not support calling Reset() on iterator.");
}
#endregion // inner running state used by state machine;
public enum RunningState
{
Init,
RunningAsync,
PendingYield,
ToBackground,
RunningSync,
CancellationRequested,
Done,
Error
} // routine user want to run;
protected readonly IEnumerator _innerRoutine; // current running state;
private RunningState _state;
// last running state;
private RunningState _previousState;
// temporary stores current yield return value
// until we think Unity coroutine engine is OK to get it;
private object _pendingCurrent; /// <summary>
/// Gets state of the task.
/// </summary>
public TaskState State
{
get
{
switch (_state)
{
case RunningState.CancellationRequested:
return TaskState.Cancelled;
case RunningState.Done:
return TaskState.Done;
case RunningState.Error:
return TaskState.Error;
case RunningState.Init:
return TaskState.Init;
default:
return TaskState.Running;
}
}
} /// <summary>
/// Gets exception during running.
/// </summary>
public System.Exception Exception { get; protected set; } public Task(IEnumerator routine)
{
_innerRoutine = routine;
// runs into background first;
_state = RunningState.Init;
} /// <summary>
/// Cancel the task till next iteration;
/// </summary>
public void Cancel()
{
if (State == TaskState.Running)
{
GotoState(RunningState.CancellationRequested);
}
} /// <summary>
/// A co-routine that waits the task.
/// </summary>
public IEnumerator Wait()
{
while (State == TaskState.Running)
yield return null;
} // thread safely switch running state;
protected void GotoState(RunningState state)
{
if (_state == state) return; lock (this)
{
// maintainance the previous state;
_previousState = _state;
_state = state;
}
} // thread safely save yield returned value;
protected void SetPendingCurrentObject(object current)
{
lock (this)
{
_pendingCurrent = current;
}
} // actual MoveNext method, controls running state;
protected bool OnMoveNext()
{
// no running for null;
if (_innerRoutine == null)
return false; // set current to null so that Unity not get same yield value twice;
Current = null; // loops until the inner routine yield something to Unity;
while (true)
{
// a simple state machine;
switch (_state)
{
// first, goto background;
case RunningState.Init:
GotoState(RunningState.ToBackground);
break;
// running in background, wait a frame;
case RunningState.RunningAsync:
return true; // runs on main thread;
case RunningState.RunningSync:
MoveNextUnity();
break; // need switch to background;
case RunningState.ToBackground:
GotoState(RunningState.RunningAsync);
// call the thread launcher;
MoveNextAsync();
return true; // something was yield returned;
case RunningState.PendingYield:
if (_pendingCurrent == ZS.JumpBack)
{
// do not break the loop, switch to background;
GotoState(RunningState.ToBackground);
}
else if (_pendingCurrent == ZS.JumpToUnity)
{
// do not break the loop, switch to main thread;
GotoState(RunningState.RunningSync);
}
else
{
// not from the ZS, then Unity should get noticed,
// Set to Current property to achieve this;
Current = _pendingCurrent; // yield from background thread, or main thread?
if (_previousState == RunningState.RunningAsync)
{
// if from background thread,
// go back into background in the next loop;
_pendingCurrent = ZS.JumpBack;
}
else
{
// otherwise go back to main thread the next loop;
_pendingCurrent = ZS.JumpToUnity;
} // end this iteration and Unity get noticed;
return true;
}
break; // done running, pass false to Unity;
case RunningState.Done:
case RunningState.CancellationRequested:
default:
return false;
}
}
} // background thread launcher;
protected void MoveNextAsync()
{
ThreadPool.QueueUserWorkItem(
new WaitCallback(BackgroundRunner));
} // background thread function;
protected void BackgroundRunner(object state)
{
// just run the sync version on background thread;
MoveNextUnity();
} // run next iteration on main thread;
protected virtual void MoveNextUnity()
{
try
{
// run next part of the user routine;
var result = _innerRoutine.MoveNext(); if (result)
{
// something has been yield returned, handle it;
SetPendingCurrentObject(_innerRoutine.Current);
GotoState(RunningState.PendingYield);
}
else
{
// user routine simple done;
GotoState(RunningState.Done);
}
}
catch (System.Exception ex)
{
// exception handling, save & log it;
this.Exception = ex;
Debug.LogError(string.Format("{0}\n{1}", ex.Message, ex.StackTrace));
// then terminates the task;
GotoState(RunningState.Error);
}
}
}
}
使用情况:
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Threading;
using UnityEngine;
using UnityEngine.Events;
using ZSThread; public class RunLogicManager : SingletonLimit<RunLogicManager>
{
private RunningBaseState mState;
private Stack<RunningBaseState> mStateStack = new Stack<RunningBaseState>(); public static RunLogicManager Instance
{
get
{
return (RunLogicManager)mInstance;
}
set
{
mInstance = value;
}
} private void GotoState(RunningBaseState state)
{
if (mStateStack.Count > )
{
var tempState = mStateStack.Pop();
tempState.Exit();
}
mState = state;
mStateStack.Push(mState);
mState.Enter();
} // Use this for initialization
void Start ()
{
GotoState(RunningBaseState.time); ExceptionTask t = new ExceptionTask(AsyncCoroutine(), mono =>
{
ZSLoger.Instance.Loger.Debug("处理异常，此调用处于多线程.");
}, this);
StartCoroutine(t);
} IEnumerator AsyncCoroutine()
{
while (true)
{
File.OpenRead("NotExist");
Thread.Sleep();
yield return ZS.JumpToUnity;
ZSLoger.Instance.Loger.Debug("Jump 2 unity in AsyncCoroutine.");
yield return ZS.JumpBack;
}
} // Update is called once per frame
void Update ()
{ }
} public class ExceptionTask : Task
{
private MonoBehaviour mono;
private UnityAction<MonoBehaviour> exceptionHandle;
public ExceptionTask(IEnumerator routine, UnityAction<MonoBehaviour> exceptionHandle, MonoBehaviour mono) : base(routine)
{
this.mono = mono;
this.exceptionHandle = exceptionHandle;
} // run next iteration on main thread;
protected override void MoveNextUnity()
{
try
{
// run next part of the user routine;
var result = _innerRoutine.MoveNext(); if (result)
{
// something has been yield returned, handle it;
SetPendingCurrentObject(_innerRoutine.Current);
GotoState(RunningState.PendingYield);
}
else
{
// user routine simple done;
GotoState(RunningState.Done);
}
}
catch (System.Exception ex)
{
this.Exception = ex;
//Debug.LogError(string.Format("{0}\n{1}", ex.Message, ex.StackTrace));
ZSLoger.Instance.Loger.Debug("handle exception.");
if (exceptionHandle != null)
{
exceptionHandle.Invoke(mono);
}
// then terminates the task;
GotoState(RunningState.Error);
}
}
}
输出结果:
关于unity协程深度的扩展参考博文:http://blog.csdn.net/ybhjx/article/details/55188777