C# Thread.Suspend方法代码示例

        static void Main(string[] args)
        {
            Console.WriteLine("主线程-创建线程实例");
            //创建子线程
            Thread thread = new Thread(new ThreadStart(ThreadProc));
            Console.WriteLine("主线程-子线程状态:{0}", thread.ThreadState);
            //启动子线程
            Console.WriteLine("主线程调用start方法");
            thread.Start();
            Console.WriteLine("主线程-子线程状态{0}", thread.ThreadState);
            Thread.Sleep(5000);
            Console.WriteLine("主线程-调用suspend方法");
            thread.Suspend();
            Console.WriteLine("主线程-子线程状态{0}", thread.ThreadState);
            Thread.Sleep(1000);
            Console.WriteLine("主线程-调用resume方法");

            thread.Resume();
            Console.WriteLine("主线程-子线程状态{0}", thread.ThreadState);

            Thread.Sleep(5000);
            Console.WriteLine("主线程-调用abort方法");
            thread.Abort();
            Console.WriteLine("主线程-子线程状态{0}", thread.ThreadState);
            Console.WriteLine("主线程-调用join方法");
            Console.WriteLine("主线程-子线程状态{0}", thread.ThreadState);
            Console.Read();
        }

        public void Teste_MultiThreading()
        {
            // Thread Corrente
            // Thread.CurrentThread.ManagedThreadId;

            ThreadStart pontoEntrada = new ThreadStart(ExecutarTeste);

            Thread _thread = new Thread(pontoEntrada);
            _thread.Name = "Thread principal...";
            _thread.Start();

            _thread.Suspend();
            _thread.Resume();
            _thread.Abort();

            try
            {

            }
            catch (ThreadAbortException)
            {

                throw;
            }
        }

		public void Run()
		{
			Thread tA = new Thread( new ThreadStart( ThreadA ) );
			Thread tB = new Thread( new ThreadStart( ThreadB ) );

			Thread.CurrentThread.Name = "Main thread";
			tA.Name = "Thread A";
			tB.Name = "Thread B";

			tA.Start();
			tB.Start();
			System.Console.WriteLine( "Suspending thread A" );
			Thread.Sleep( 100 );
			tA.Suspend();
			Thread.Sleep( 2500 );
			System.Console.WriteLine( "Suspending thread B" );
			tB.Suspend();
			Thread.Sleep( 2500 );
			System.Console.WriteLine( "Running GC..." );
			GC.Collect();
			System.Console.WriteLine( "Suspending main thread" );
			Thread.Sleep( 2500 );
			tA.Resume();
			_mreA.Set();
			Thread.Sleep( 2500 );
			tB.Resume();
			_mreB.Set();
		}

        static void Main(string[] args)
        {
            //主线程不需要显示启动
            Thread.CurrentThread.Name = "主线程";
            Console.WriteLine("主线程启动");

            //创建用户线程
            Thread thread = new Thread(new ThreadStart(ThreadProc));
            //启动用户线程
            thread.Start();
            //suspend user thread
            thread.Suspend();
            Console.WriteLine("用户线程挂起");
            Console.WriteLine(thread.IsAlive);
            //suspend 5s
            Thread.Sleep(5000);
            thread.Resume();
            Console.WriteLine("用户线程恢复");

            //suspend 5s
            Thread.Sleep(5000);
            //结束用户线程
            thread.Abort();
            thread.Join();
            Console.WriteLine("用户线程结束");

            Console.Read();
        }

 static void Main(string[] args)
 {
     ThreadStart ts = new ThreadStart(Method);
     Thread t = new Thread(ts);
     t.Start(); // Запуск потока.
     Console.WriteLine("Нажмите любую клавишу для остановки");
     Console.ReadKey();
     t.Suspend(); // Приостановка потока.
     Console.WriteLine("Поток остановлен!");
     Console.WriteLine("Нажмите любую клавишу для возобновления");
     Console.ReadKey();
     t.Resume(); // Возобновление работы.
 }

 static void Main(string[] args)
 {
     ThreadStart ts = new ThreadStart(Method);
     Thread t = new Thread(ts);
     t.Start();
     Console.WriteLine("Press any key to stop stream");
     Console.ReadKey();
     t.Suspend();
     Console.WriteLine("Stream stoped");
     Console.WriteLine("Press any key to continue stream");
     Console.ReadKey();
     t.Resume();
 }

        public static void Main(string[] args)
        {
            Console.Write("Diga o nome do arquivo de img: ");
            string nomeArq = Console.ReadLine();
            Console.Write("Diga o tamanho do embacamento: ");
            int coef = Int32.Parse(Console.ReadLine());
            Image imagem = Image.FromFile(nomeArq);
            Bitmap bitmap = new Bitmap(imagem);
            Console.Write("Quantas thread horizontais? ");
            int threadsH = Int32.Parse(Console.ReadLine());
            Console.Write("Quantas thread verticais? ");
            int threadsV = Int32.Parse(Console.ReadLine());
            totalThreads = threadsH * threadsV;

            ThreadEmb[,] threads = new ThreadEmb[threadsV, threadsH];

            int i, j;
            int qtdX = bitmap.Width / threadsH;
            int qtdY = bitmap.Height / threadsV;
            Graphics g = Graphics.FromImage(bitmap);

            for(i = 0; i < threadsV; i++)
                for (j = 0; j < threadsH; j++)
                    threads[i, j] = new ThreadEmb((Bitmap)bitmap.Clone(), coef, qtdX * j, qtdX, qtdY * i, qtdY, i, j);

            Thread t;
            ThreadStart ts;

            threadPrincipal = Thread.CurrentThread;

            for (i = 0; i < threadsV; i++)
                for (j = 0; j < threadsH; j++)
                {
                    ts = new ThreadStart(threads[i, j].Iniciar);
                    t = new Thread(ts);
                    t.Start();
                }

            //while (threadCompletas < totalThreads) { }

            threadPrincipal.Suspend();

            for (i = 0; i < threadsV; i++)
                for (j = 0; j < threadsH; j++)
                    threads[i,j].desenhaResultado(g);

            bitmap.Save("editado_" + nomeArq);
        }

        static void Main()
        {
            CharGenerator g1 = new CharGenerator();
            CharGenerator g2 = new CharGenerator();
            CharGenerator g3 = new CharGenerator();
            Thread t1 = new Thread(new ThreadStart(g1.GenerateChar));
            Thread t2 = new Thread(new ThreadStart(g2.GenerateChar));
            Thread t3 = new Thread(new ThreadStart(g3.GenerateChar));
            t1.Start();
            t2.Start();
            t3.Start();

            string input = "";

            do
            {

                Console.WriteLine("Enter \"try\" when you're ready, \"exit\" to escape");
                input = Console.ReadLine();

                if (input == "try" || input == "t")
                {
                    t1.Suspend();
                    t2.Suspend();
                    t3.Suspend();
                    if (g1.ch == g2.ch && g2.ch == g3.ch)
                    {
                        Console.WriteLine(g1.ch + " " + g2.ch + " " + g3.ch + " won");
                    }
                    else
                    {
                        Console.WriteLine(g1.ch + " " + g2.ch + " " + g3.ch + " lost");
                    }

                    t1.Resume();
                    t2.Resume();
                    t3.Resume();
                }
                Thread.Sleep(100);
            } while (input != "exit");

            g1.end = true;
            g2.end = true;
            g3.end = true;

            return;
        }

 /// <summary>
 /// http://stackoverflow.com/questions/285031/how-to-get-non-current-threads-stacktrace/14935378#14935378
 /// </summary>
 /// <param name="targetThread"></param>
 /// <returns></returns>
 private static StackTrace GetStackTrace(Thread targetThread)
 {
     ManualResetEventSlim fallbackThreadReady = new ManualResetEventSlim();
     ManualResetEventSlim exitedSafely = new ManualResetEventSlim();
     try
     {
         new Thread(delegate()
         {
             fallbackThreadReady.Set();
             if (!exitedSafely.Wait(200))
             {
                 try
                 {
                     targetThread.Resume();
                 }
                 catch (Exception) {/*Whatever happens, do never stop to resume the main-thread regularly until the main-thread has exited safely.*/}
             }
         }).Start();
         fallbackThreadReady.Wait();
         //From here, you have about 200ms to get the stack-trace.
         targetThread.Suspend();
         StackTrace trace = null;
         try
         {
             trace = new StackTrace(targetThread, true);
         }
         catch (ThreadStateException)
         {
             //failed to get stack trace, since the fallback-thread resumed the thread
             //possible reasons:
             //1.) This thread was just too slow
             //2.) A deadlock ocurred
             //Automatic retry seems too risky here, so just return null.
         }
         try
         {
             targetThread.Resume();
         }
         catch (ThreadStateException) {/*Thread is running again already*/}
         return trace;
     }
     finally
     {
         //Just signal the backup-thread to stop.
         exitedSafely.Set();
     }
 }

        public void Start()
        {
            System.Threading.Thread work1 = new System.Threading.Thread (WorkA);
            System.Threading.Thread work2 = new System.Threading.Thread (WorkB);

            work1.Priority = ThreadPriority.Lowest;
            work2.Priority = ThreadPriority.Highest;

            work1.Start();
            work2.Start();

            work1.Suspend();
            Console.ReadLine();
            work1.Resume();

            Console.ReadLine();
        }

 /// <summary>
 /// 报警线程
 /// </summary>
 public void run()
 {
     strSend = "正在初始化...";
     label1.Text = "正在初始化...";
     send(strSend);
     Thread.Sleep(5000);
     showBreakRecord();
     Thread t1 = new Thread(new ThreadStart(showBadRecord));
     t1.IsBackground = true;
     t1.Start();
     while (true)
     {
         //-----设置断网信息输出时间间隔-----
         Thread.Sleep(120000);
         t1.Suspend();
         showBreakRecord();
         t1.Resume();
     }
 }

        public static ApplicationHangException CreateForThread(Thread thread)
        {
            StackTrace tt = null;
            if (!IsMono)
            {
#if !CORECLR
#pragma warning disable 0618
                try
                {
                    thread.Suspend();
                }
                catch
                {
                    return null;
                }
                try
                {
                    tt = new System.Diagnostics.StackTrace(thread, false);
                }
                catch (ThreadStateException)
                {
                }
                try
                {
                    thread.Resume();
                }
                catch (Exception)
                {
                    Thread.Sleep(3000);
                    thread.Resume();
                }
#pragma warning restore 0618
#endif
            }


            return new ApplicationHangException(
                tt, 
                thread.Name
                );
        }

 public static StackTrace GetThreadStackTrace(Thread targetThread, bool needFileInfo)
 {
     StackTrace stackTrace;
     if (targetThread == Thread.CurrentThread) // current thread
     {
         stackTrace = new StackTrace(needFileInfo); // skip ... frames (reporter stack)
     }
     else // other thread
     {
         targetThread.Suspend();
         try
         {
             stackTrace = new StackTrace(targetThread, needFileInfo);
         }
         finally
         {
             targetThread.Resume();
         }
     }
     return stackTrace;
 }

        static void Main(string[] args)
        {
            Thread thr = new Thread(OnPrint);
            thr.Name = "Thread Two";
            thr.Start();

            Thread.Sleep(1000);

            /*Suspend thread*/
            /*When thread suspend no exception. 
            */

            thr.Suspend();

            Thread.Sleep(1000);
            if ((thr.ThreadState & ThreadState.Suspended) > 0)
                thr.Resume();

            thr.Join();
                        /* Thread don't finish. If other thread join it, they can wait and wait forever*/

            Console.WriteLine("Main thread terminating");
            Console.ReadLine(); 
        }

        private int _instScanInterval = 200; //取指令周期,单位：毫秒

        #endregion Fields

        #region Constructors

        /// <summary>
        /// 构造函数
        /// </summary>
        public TansVehicle()
        {
            _instExeThread = new Thread(new ThreadStart(InstExeThreadProc));
            _instExeThread.Suspend(); //挂起
        }