异步指令的执行机制

//------------------------------------------摘要------------------------------------------
// 产品名称：动作队列
// 文 件 名：ActionsQueue
// 文件说明：
// 机器名称：EIBJDE0153
// 作　　者：zhengping.pan
// 创建日期：2017-12-19 11:31:09
//----------------------------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace EURO.DeviceManager.MultiNeedlesArm.DataModel
{
    /// <summary>
    /// 动作队列
    /// </summary>
    internal class ActionsQueue : Queue<ActionInvoke>
    {

        #region 字段
        /// <summary>
        /// 队列名称
        /// </summary>
        public string Name { get; set; }

        ///// <summary>
        ///// 执行的当前队列中的动作。用于在执行下一个时，取上一个的动作。
        ///// </summary>
        private ActionInvoke _currentAction = null;

        /// <summary>
        /// 执行的当前方法名称
        /// </summary>
        private string _currentFunctionName;

        /// <summary>
        /// 控制列表访问的锁
        /// </summary>
        private object _queueLock = new object();

        /// <summary>
        /// 是否请求停止
        /// </summary>
        //private bool _IsQueryStop = false;

        private Thread _actionsThread = null;

        /// <summary>
        /// 阻塞或继续动作线程
        /// </summary>
        private AutoResetEvent _ar_Excute = new AutoResetEvent(false);
        #endregion

        #region 构造
        public ActionsQueue()
        {
            StartActionsThread();
        }
        #endregion

        #region 公有方法

        /// <summary>
        /// 线程继续
        /// </summary>
        public void Set()
        {
            this._ar_Excute.Set();
        }

        /// <summary>
        /// 开始动作线程
        /// </summary>
        private void StartActionsThread()
        {
            _actionsThread = new Thread(new ThreadStart(Excute)) { IsBackground = true, Priority = ThreadPriority.Normal };
            _actionsThread.Start();
        }

        /// <summary>
        /// 释放
        /// </summary>
        public void Release()
        {
            this.Clear();
            if (_actionsThread != null)
            {
                _actionsThread.Abort();
            }
            this.Clear();
        }

        #endregion

        #region 私有方法


        /// <summary>
        /// 执行队列循环
        /// </summary>

        private void Excute()
        {
            while (true)
            {
               DoDequeue();
            }
        }

        /// <summary>
        /// 执行队列中一个方法
        /// </summary>
        private void DoDequeue()
        {
            if (this.Count == 0)
            {
                _currentAction = null;
                _ar_Excute.WaitOne();
            }
            if (this.Count > 0)
            {
                    ActionInvoke func = this.Dequeue();
                    if (null == func)
                    {
                        ErrorEventManager.Manager.SetInforStr(string.Format("{0} .Dequeue is NULL !", this.Name));
                        return;
                    }
                    // 上条指令的延时
                    if (_currentAction != null && _currentAction.NextDelayTime > 0)
                    {
                        Thread.Sleep(_currentAction.NextDelayTime);
                    }

                    // 如果是不需要判断ACK的方法,直接执行.
                    if (func.Action.Method.Name.ToLower().Contains("finishedmethod") || !func.IsNeedAck || func.SMID <= 0)
                    {
                        _currentFunctionName = func.TaskName;
                        try
                        {
                            func.Action.Method.Invoke(func.Action.Target, func.Parameters);
                        }
                        catch(Exception ex)
                        {
                            string strDescribe = ex.ToString();
                            ErrorEventManager.Manager.SetInformation(new ErrorEventArgs(ErrorRank.Error, DeviceErrorCode.InvokeError, strDescribe));
                            throw new ErrorException(DeviceErrorCode.InvokeError, strDescribe);
                            //break;
                        }
                        _currentAction = func;
                    }
                    else
                    {
                        //==================================================================
                        while (!ACKAndFinishManager.ACKManager.IsAllAccept())
                        {
                            Thread.Sleep(10);
                        }
                        while (!ACKAndFinishManager.FinishManager.IsThisIDAccept(func.SMID))
                        {
                            Thread.Sleep(10);
                        }
                        #region Finish锁
                        lock (ACKAndFinishManager.FinishLockDic[func.SMID])
                        {
                            #region ACK锁
                            lock (ACKAndFinishManager.AckLockObj)
                            {
                                if (func.IsNeedAck)
                                {
                                    ACKAndFinishManager.ACKManager.SetState(func.SMID, false);
                                    ACKAndFinishManager.FinishManager.SetState(func.SMID, false);
                                }
                                else
                                {

                                }
                                func.IsFinished.Value = false;
                                try
                                {
                                    func.Action.Method.Invoke(func.Action.Target, func.Parameters);
                                }
                                catch(Exception ex)
                                {
                                    string strDescribe = ex.ToString();
                                    ErrorEventManager.Manager.SetInformation(new ErrorEventArgs(ErrorRank.Error, DeviceErrorCode.InvokeError, strDescribe));
                                    throw new ErrorException(DeviceErrorCode.InvokeError, strDescribe);
                                    //break;
                                }
                                _currentAction = func;

                                // 等待ACK
                                int ackCount = 0;
                                int sendCount = 0;
                                // 如果需要等待ACK
                                while (!ACKAndFinishManager.ACKManager.IsThisIDAccept(func.SMID) && func.IsNeedAck)
                                {
                                    Thread.Sleep(25);
                                    ackCount++;
                                    // 200ms没收到ACK超时
                                    if (sendCount >= 4 && ackCount >= 10)
                                    {
                                        string strDescribe = string.Format("{0} .{1} !", func.Action.Method.ToString(), ErrorCodeHelper.GetErrorInfo((int)DeviceErrorCode.NoAck));
                                        ErrorEventManager.Manager.SetInformation(new ErrorEventArgs(ErrorRank.Error, DeviceErrorCode.NoAck, strDescribe));
                                        throw new ErrorException(DeviceErrorCode.NoAck, strDescribe);
                                    }
                                    if (ackCount == 10)
                                    {
                                        if (sendCount == 2)
                                        {
                                            try
                                            {
                                                func.Action.Method.Invoke(func.Action.Target, func.Parameters);
                                            }
                                            catch (Exception ex)
                                            {
                                                string strDescribe = ex.ToString();
                                                ErrorEventManager.Manager.SetInformation(new ErrorEventArgs(ErrorRank.Error, DeviceErrorCode.InvokeError, strDescribe));
                                                throw new ErrorException(DeviceErrorCode.InvokeError, strDescribe);
                                                //break;
                                            }
                                        }
                                        sendCount++;
                                        ackCount = 0;
                                    }
                                }
                            }
                            #endregion
                            //======================================================
                            // Finished事件
                            DateTime dtStart = DateTime.Now;
                            while (!ACKAndFinishManager.FinishManager.IsThisIDAccept(func.SMID))
                            {
                                Thread.Sleep(20);
                                TimeSpan ts = DateTime.Now - dtStart;
                                if (ts.TotalSeconds > 20)
                                {
                                    if (func.IsNeedAck)
                                    {
                                        string strDescribe = string.Format("{0} .{1} !", func.Action.Method.ToString(), ErrorCodeHelper.GetErrorInfo((int)DeviceErrorCode.NoFinish));
                                        ErrorEventManager.Manager.SetInformation(new ErrorEventArgs(ErrorRank.Error, DeviceErrorCode.NoFinish, strDescribe));
                                        throw new ErrorException(DeviceErrorCode.NoFinish, strDescribe);
                                        //break;
                                    }
                                }
                            }
                            Thread.Sleep(20);
                        }
                        #endregion  //// Finish锁结束
                    }

            }

        }

        #endregion

    }
}