结合Thread Ninja明确与处理异步协程中的异常

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(1000);
            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}
{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 > 0)
        {
            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(1000);
            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}
{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