/// <summary>
 /// Waits for all incoming threads to be in wait()
 ///  methods.
 /// </summary>
 public static void AwaitState(ThreadState state, params ThreadClass[] threads)
 {
     while (true)
     {
         bool done = true;
         foreach (ThreadClass thread in threads)
         {
             if (thread.State != state)
             {
                 done = false;
                 break;
             }
         }
         if (done)
         {
             return;
         }
         if (Random().NextBoolean())
         {
             [email protected]();
         }
         else
         {
             Thread.Sleep(1);
         }
     }
 }

 private void btnPause_Click(object sender, EventArgs e)
 {
     this.Cursor = Cursors.WaitCursor;
     if (state == ThreadState.Running) // Press Pause Button's
     {
         if (Algorithm.Algorithm.GetInstance().Pause())
         {
             state = ThreadState.Suspended;
             btnStart.Enabled = true;
             btnPause.Enabled = false;
             btnPause.Text = "&Pause";
             btnStop.Enabled = true;
             btnStart.Text = "&Resume";
             if (ResultForm._setting.AutoSave_OnStopped)
             {
                 Save(Algorithm.Algorithm.GetInstance().GetBestChromosome());
             }
         }
     }
     else if (state == ThreadState.Stopped || state == ThreadState.Aborted) // Press Sava Button's
     {
         Save(Algorithm.Algorithm.GetInstance().GetBestChromosome());
         btnStart.Enabled = true;
         btnPause.Enabled = false;
         btnPause.Text = "&Pause";
         btnStop.Enabled = false;
     }
     this.Cursor = Cursors.Default;
 }

 public Thread(Closure closure, int stackSize)
 {
     ThreadClosure = closure;
     State = new ThreadState(stackSize);
     State.CurrentInstruction = new InstructionPointer(closure.Func, closure.ClosedVars, 0);
     State.CurrentInstruction.InstructionIndex = -1;
 }

 public override bool CanComplete(ThreadState threadState)
 {
     // A DelayedUnlock can be completed even if the thread does not
     // own the lock, then the execution does not affect anything
     // except that the instruction acts as a barrier preventing
     // instruction before to be completed after the unlock
     return true;
 }

        public static ThreadState _1_SimplifyThreadState(ThreadState ts)
		{
            // Technique to convert threadstate to one of the 4 most useful values:
            // Unstarted, Running, WaitSleepJoin, and Stopped
            return ts & (ThreadState.Unstarted | 
				         ThreadState.WaitSleepJoin | 
						 ThreadState.Stopped);
        }

        private readonly ThreadState _threadState; // State of the thread

        #endregion Fields

        #region Constructors

        /// <summary> Constructor. </summary>
        /// <param name="interval"> The execution interval. </param>
        /// <param name="action">   The action to execute. </param>
        public TimedAction(double interval, Action action)
        {
            _action = action;
            _threadState = new ThreadState {IsRunning = false};

            _actionTimer = new Timer(interval) {Enabled = false, SynchronizingObject = null};
            _actionTimer.Elapsed += OnActionTimer;
        }

        private readonly ThreadState _threadState; // State of the thread

        #endregion Fields

        #region Constructors

        /// <summary> Constructor. </summary>
        /// <param name="disposeStack">Dispose stack to add itself to</param>
        /// <param name="interval"> The execution interval. </param>
        /// <param name="action">   The action to execute. </param>
        public TimedAction(DisposeStack disposeStack, double interval, Action action)
        {
            disposeStack.Push(this);
            _action = action;
            _threadState = new ThreadState {IsRunning = false};

            _actionTimer = new Timer(interval) {Enabled = false, SynchronizingObject = null};
            _actionTimer.Elapsed += OnActionTimer;
        }

        public override bool CanComplete(ThreadState threadState)
        {
            // TODO: (much later) support exception here
            VMValue_objectinst vinst = (VMValue_objectinst)threadState.GetValue(obj);
            if(vinst.HoldingLockThreadID != threadState.ThreadID)
                throw new Exception("Calling pulse on a lock we don't possess");

            return true;
        }

 public ThreadTraceInfo(int id, string name, DateTime start, float cpuUsage, TimeSpan totalCpuUsageTime, ThreadState state)
 {
     _id = id;
     _name = name;
     _start = start;
     _cpuUsage = cpuUsage;
     _totalCpuUsageTime = totalCpuUsageTime;
     _state = state;
 }

 public ThreadSurrogated(Thread thread)
 {
     Id = thread.ManagedThreadId;
     Name = thread.Name;
     Priority = thread.Priority;
     State = thread.ThreadState;
     IsBackground = thread.IsBackground;
     IsThreadPoolThread = thread.IsThreadPoolThread;
 }

        public void Start(Action<Exception> threadFailedHandler)
        {
            if (threadFailedHandler != null)
                ThreadFailed += threadFailedHandler;

            StartCore();

            m_State = ThreadState.Starting;
            m_Thread.Start();
        }

        /// <summary>
        /// 创建线程
        /// </summary>
        /// <param name="name"></param>
        /// <param name="task"></param>
        /// <param name="isBackground"></param>
        /// <param name="apartmentState"></param>
        public SmartThread(Action task, string name = null, bool isBackground = true, ApartmentState apartmentState = ApartmentState.MTA)
        {
            if (task == null)
                throw new ArgumentNullException("task");

            InnerThread = new System.Threading.Thread(()=>task()) { Name = name, IsBackground = isBackground };
            InnerThread.SetApartmentState(apartmentState);

            mutex = new ResetEvent(false);
            State = ThreadState.NotStarted;
        }

 // A lock action can be completed if the lock is free
 // or it is currently hold by the same thread
 public override bool CanComplete(ThreadState threadState)
 {
     // A DelayedLock can only be completed if the object instance is not locked
     // or it is already locked by this thread
     VMValue_objectinst vinst = (VMValue_objectinst)threadState.GetValue(obj);
     if((vinst.HoldingLockThreadID == threadState.ThreadID) ||
         (vinst.HoldingLockThreadID == -1))
         return true;
     else
         return false;
 }

 /// <summary>
 /// Creates a new <seealso cref="DocumentsWriterPerThreadPool"/> with a given maximum of <seealso cref="ThreadState"/>s.
 /// </summary>
 public DocumentsWriterPerThreadPool(int maxNumThreadStates)
 {
     if (maxNumThreadStates < 1)
     {
         throw new System.ArgumentException("maxNumThreadStates must be >= 1 but was: " + maxNumThreadStates);
     }
     ThreadStates = new ThreadState[maxNumThreadStates];
     NumThreadStatesActive = 0;
     for (int i = 0; i < ThreadStates.Length; i++)
     {
         ThreadStates[i] = new ThreadState(null);
     }
 }

 /// <summary>
 /// Start executing the robotscript
 /// </summary>
 public void executeScript()
 {
     try
     {
         thread = new Thread(new ThreadStart(scriptexecutor));
         thState = thread.ThreadState;
         thread.Start();
     }
     catch (ThreadStateException)
     {
         return;
     }
 }

 private Mission(eTaskType taskType, string missionName, string dllLocation, string className, string launchMethod,
     string shutDownMethod, int launchInterval, int _errorTryInterval, eMissionStatus missionStatus)
 {
     _TaskType = taskType;
     _MissionName = missionName;
     _DllLocation = string.Format(@"{0}{1}", System.AppDomain.CurrentDomain.BaseDirectory, dllLocation); ;
     _ClassName = className;
     _LaunchMethod = launchMethod;
     _ShutDownMethod = shutDownMethod;
     _LaunchInterval = launchInterval;
     _ErrorTryInterval = _errorTryInterval;
     _MissionStatus = missionStatus;
     _MissionOwnerStatus = ThreadState.Unstarted;
 }

        private static string ThreadStateAsString(ThreadState state)
        {
            var values = (ThreadState[])Enum.GetValues(typeof(ThreadState));
            var extractedValues = new List<string>();

            foreach (var value in values)
            {
                if ((state & value) == value)
                {
                    extractedValues.Add(DebuggerBase.Instance.MuiProcessor.GetString(_threadStateMuiIdentifiers[value]));
                }
            }

            return string.Join(", ", extractedValues);
        }

 // In completion stage, the lock action will actually
 // set the object's lock field to be locked by this thread
 public override void Complete(ThreadState threadState)
 {
     VMValue_objectinst vinst = (VMValue_objectinst)threadState.GetValue(obj);
     if(vinst.HoldingLockThreadID == -1)
     {
         vinst.HoldingLockThreadID = threadState.ThreadID;
         vinst.HoldingLockCount = nTimes;
     }
     else
         vinst.HoldingLockCount += nTimes;
     if(CheckerConfiguration.DoPrintExecution)
     {
         Console.WriteLine("Commiting Lock in thread " + threadState.CurrentMethod.Name + " on " + obj);
     }
 }

        public ContextSwitch(TraceEvent sw)
        {
            // Old thread id & process id
            this.OldThreadId = (int)sw.PayloadValue(0);
            this.OldProcessId = (int)sw.PayloadValue(1);
            this.NewThreadId = (int)sw.PayloadValue(3);
            this.NewProcessId = (int)sw.PayloadValue(4);
            this.State = (ThreadState)sw.PayloadValue(13);
            this.ProcessorNumber = sw.ProcessorNumber;
            this.TimeStamp = sw.TimeStamp;
            this.TimeStamp100ns = sw.TimeStamp100ns;

            // Multiply by 10 to adjust the time as 100ns
            this.NewThreadWaitTime = (int)sw.PayloadValue(15) * 10;
        }

 /// <summary>
 /// ThreadStorageView constructor.
 /// </summary>
 /// <param name="applicationId"></param>
 /// <param name="threadId"></param>
 /// <param name="state"></param>
 public ThreadStorageView(
     string applicationId,
     int threadId,
     ThreadState state
     )
     : this(-1,
     applicationId,
     null,
     threadId,
     state,
     c_noTimeSet,
     c_noTimeSet,
     0,
     false)
 {
 }