private static void MenuComandos(Thread thread) { MenuOpcao(); do { _arquivos = Directory.GetFiles(_origem).ToList(); switch (_opcao) { case "start": Thread.Sleep(3000); thread.Start(); MenuComandos(thread = new Thread(MoveFile)); break; case "pause": Thread.Sleep(3000); thread.Interrupt(); MenuComandos(thread = new Thread(MoveFile)); break; case "resume": Thread.Sleep(3000); thread.Resume(); MenuComandos(thread = new Thread(MoveFile)); break; case "abort": Thread.Sleep(3000); thread.Abort(); MenuComandos(thread = new Thread(MoveFile)); break; default: Console.WriteLine("Comando incorreto"); break; } } while (_arquivos.Count > 0); }
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(); }
public bool AbortProcessing(string p_strTitle, string p_strQuestion) { try { string strMsg = p_strQuestion; DialogResult result = MessageBox.Show(strMsg, p_strTitle, MessageBoxButtons.YesNo, MessageBoxIcon.Question); switch (result) { case DialogResult.Yes: if (this.CurrentThreadProcessSuspended) { m_oThread.Resume(); this.CurrentThreadProcessSuspended = false; } this.m_oThread.Abort(); this.CurrentThreadProcessAborted = true; this.CurrentThreadProcessIdle = true; return(true); } } catch (Exception err) { } return(false); }
/// <summary> /// Do our best to kill a thread, passing state info /// </summary> /// <param name="thread">The thread to kill</param> /// <param name="stateInfo">Info for the ThreadAbortException handler</param> public static void Kill(Thread thread, object stateInfo) { try { if (stateInfo == null) thread.Abort(); else thread.Abort(stateInfo); } catch (ThreadStateException) { #if !NETCF // Although obsolete, this use of Resume() takes care of // the odd case where a ThreadStateException is received. #pragma warning disable 0618,0612 // Thread.Resume has been deprecated thread.Resume(); #pragma warning restore 0618,0612 // Thread.Resume has been deprecated #endif } #if !NETCF if ( (thread.ThreadState & ThreadState.WaitSleepJoin) != 0 ) thread.Interrupt(); #endif }
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(); }
/// <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 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 ); }
private static void MenuOpcoes(Thread thread) { Console.Clear(); Console.WriteLine("╔═══════════════════════════════════╗"); Console.WriteLine("║ Informe a opcao desejada: ║"); Console.WriteLine("║ 1- START ║"); Console.WriteLine("║ 2- PAUSE ║"); Console.WriteLine("║ 3- RESUME ║"); Console.WriteLine("║ 4- EXIT ║"); Console.WriteLine("╚═══════════════════════════════════╝"); opcao = int.Parse(Console.ReadLine()); switch (opcao) { case 1: Console.Clear(); thread.Start(); //Console.WriteLine("Start..."); //Console.ReadKey(); MenuOpcoes(thread); break; case 2: Console.Clear(); thread.Interrupt(); //Console.WriteLine("Pause..."); //Console.ReadKey(); MenuOpcoes(thread); break; case 3: Console.Clear(); thread.Resume(); //Console.WriteLine("Resume..."); //Console.ReadKey(); MenuOpcoes(thread); break; case 4: Console.Clear(); thread.Suspend(); //Console.WriteLine("Suspend"); //Console.ReadKey(); MenuOpcoes(thread); break; default: Console.WriteLine("Este comando nao e valido!Tente novamente."); break; } }
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(); }
private static void SuspendCase() { Thread t = new Thread(() => { Thread.CurrentThread.Suspend();//.net2.0开始已经废弃挂起方法 Console.WriteLine("current abort thread id:{0}", Thread.CurrentThread.ManagedThreadId); }); t.Start(); Console.WriteLine("main thread resume child thread."); t.Resume(); Console.WriteLine("completed."); }
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; }
//중단버튼 눌렀을때 private void button1_Click(object sender, EventArgs e) { DialogResult Result; t1.Suspend(); Result = MessageBox.Show("작업을 중단할까요?", "정지", MessageBoxButtons.YesNo); if (Result == DialogResult.Yes) { this.Exit(); } else { t1.Resume(); } }
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> /// Do our best to kill a thread, passing state info /// </summary> /// <param name="thread">The thread to kill</param> /// <param name="stateInfo">Info for the ThreadAbortException handler</param> public static void Kill(Thread thread, object stateInfo) { try { if (stateInfo == null) thread.Abort(); else thread.Abort(stateInfo); } catch (ThreadStateException) { // Although obsolete, this use of Resume() takes care of // the odd case where a ThreadStateException is received. thread.Resume(); } if ( (thread.ThreadState & ThreadState.WaitSleepJoin) != 0 ) thread.Interrupt(); }
/// <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(); } }
/// <summary> /// Do our best to kill a thread, passing state info /// </summary> /// <param name="thread">The thread to kill</param> /// <param name="stateInfo">Info for the ThreadAbortException handler</param> public static void Kill(Thread thread, object stateInfo) { try { if (stateInfo == null) thread.Abort(); else thread.Abort(stateInfo); } catch (ThreadStateException) { // This is deprecated but still needed in this case // in order to kill the thread. The warning can't // be disabled because the #pragma directive is not // recognized by the .NET 1.1 compiler. thread.Resume(); } if ( (thread.ThreadState & ThreadState.WaitSleepJoin) != 0 ) thread.Interrupt(); }
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; }
/// <summary> /// Do our best to kill a thread, passing state info /// </summary> /// <param name="thread">The thread to kill</param> /// <param name="stateInfo">Info for the ThreadAbortException handler</param> public static void Kill(Thread thread, object stateInfo) { try { if (stateInfo == null) thread.Abort(); else thread.Abort(stateInfo); } catch (ThreadStateException) { // Although obsolete, this use of Resume() takes care of // the odd case where a ThreadStateException is received // so we continue to use it. #pragma warning disable 618 thread.Resume(); #pragma warning restore 618 } if ( (thread.ThreadState & ThreadState.WaitSleepJoin) != 0 ) thread.Interrupt(); }
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 void StartThreadService() { // ThreadStart runnerThreadStart = new ThreadStart(RunnerThreadLoop); _thdRunner = new Thread(runnerThreadStart); _runnerDelegate += new RunnerDelegate(Runner); // start worker threads. if ( _thdRunner.IsAlive == true ) { _thdRunner.Resume(); } else { _thdRunner.Start(); } }
public void Resume() { _thread.Resume(); }
public static void Kill(Thread thread) { try { thread.Abort(); } catch (ThreadStateException) { #pragma warning disable 618 thread.Resume(); #pragma warning restore 618 } if ((thread.ThreadState & ThreadState.WaitSleepJoin) != 0) thread.Interrupt(); }
private bool KillThread(Thread thread) { if (thread != null) { try { if (((thread.ThreadState & ThreadState.Suspended) > ThreadState.Running) || ((thread.ThreadState & ThreadState.SuspendRequested) > ThreadState.Running)) { try { thread.Resume(); } catch { } } thread.Abort(); return true; } catch { } } return false; }
static void Main(string[] args) { manualstop = false; serverstate = ServerThreadStates.STOP; serverthread = new Thread(new ThreadStart(ThreadProc)); serverthread.Start(); int v; do { Console.WriteLine("1 - Start Processor"); Console.WriteLine("2 - Stop Processor"); Console.WriteLine("3 - Restart Processor"); Console.WriteLine("4 - Exit"); try { v = int.Parse(Console.ReadLine()); } catch(Exception e){ v=0; } switch(v){ case 1: if(serverstate==ServerThreadStates.STOP){ Console.WriteLine("Starting Server....."); serverstate = ServerThreadStates.START; serverthread.Resume(); }else Console.WriteLine("Server is already started."); break; case 2: if(serverstate!=ServerThreadStates.STOP){ Console.WriteLine("Stopping Server....."); serverstate = ServerThreadStates.STOP; manualstop = true; server.Stop(); }else Console.WriteLine("Server is not running."); break; case 3: if(serverstate !=ServerThreadStates.STOP){ Console.WriteLine("Restarting Server...."); serverstate = ServerThreadStates.RESTART; manualstop = true; server.Stop(); }else Console.WriteLine("Server is not running."); break; case 4: if(serverstate !=ServerThreadStates.STOP) { Console.WriteLine("Stopping Server....."); serverstate = ServerThreadStates.EXIT; manualstop = true; server.Stop(); } else { serverstate = ServerThreadStates.EXIT; serverthread.Resume(); } break; default: Console.WriteLine("Bad Command"); break; } Thread.Sleep(1000); }while(v!=4); serverthread = null; }
public static int main() { // http://msdn.microsoft.com/en-us/library/3y1sfaz2.aspx // https://sites.google.com/a/jsc-solutions.net/backlog/knowledge-base/2014/201411/20141116 // https://sites.google.com/a/jsc-solutions.net/backlog/knowledge-base/2014/201411/20141122 // http://www.sockets.com/winsock.htm#Bind // http://msdn.microsoft.com/en-us/library/wf2w9f6x.aspx Console.WriteLine("20141104 does this device support speaker music?"); // System.Collections.Generic.EqualityComparer`1[<foo>j__TPar] for Boolean Equals(<foo>j__TPar, <foo>j__TPar) used at // LP<>f__AnonymousType0_1 type0_10; var xx = new { foo = "xhello from outer scope" }; // we dont do virtuals yet // yet. why wouldnt jsc call the correct ToString instead without virtual? Console.WriteLine(xx.ToString()); Func<string, Action> y = o => { Console.WriteLine("hello there:"); Console.WriteLine((string)o); //Console.WriteLine("hello there"); //return "done"; return delegate { Console.WriteLine("cannot return long, but can return delegate! " + xx.foo); }; }; // threadpool! var x = y("goo, delegate invoke now works?"); //Console.WriteLine(x); x(); Action a = new MyClass { Field1 = "Field1" }.Invoke; a(); // http://bartoszmilewski.com/2011/10/10/async-tasks-in-c11-not-quite-there-yet/ //var ttt = ThreadPool.QueueUserWorkItem( // new WaitCallback( // delegate // { // Console.WriteLine("at QueueUserWorkItem"); // } // ) //); // X:\jsc.svn\examples\java\hybrid\Test\JVMCLRThreadPool\JVMCLRThreadPool\Program.cs //TaskScheduler.Current. var tt = new Thread( delegate() { Console.WriteLine("can the thread access outer scope?"); Console.WriteLine("!"); Console.WriteLine(xx.foo); // http://stackoverflow.com/questions/13322709/use-of-undeclared-identifier-true // TestFunc.exe.c(1154) : error C2065: 'true' : undeclared identifier var ok = 1; while (ok == 1) { // this keeps going even if the main thread quits? Console.Write("."); Thread.Sleep(100); } } ); tt.Start(); Console.Beep(1200, duration: 1000); tt.Suspend(); Console.Beep(800, duration: 1000); tt.Resume(); Console.Beep(1200, duration: 1000); return 0; }
public void WaitAllWithTimeoutAndSpuriousWake () { /* This is to test that WaitEvent.WaitAll is not going to wait largely * more than its timeout. In this test, it shouldn't wait more than * 1500 milliseconds, with its timeout being 1000ms */ using (ManualResetEvent mre1 = new ManualResetEvent (false)) using (ManualResetEvent mre2 = new ManualResetEvent (false)) using (ManualResetEvent ready = new ManualResetEvent (false)) { var thread = new Thread (() => { ready.Set (); WaitHandle.WaitAll (new [] { mre1, mre2 }, 1000); }); thread.Start (); ready.WaitOne (); Thread.Sleep (10); // wait a bit so we enter WaitHandle.WaitAll ({mre1, mre2}) DateTime end = DateTime.Now.AddMilliseconds (500); while (DateTime.Now < end) { thread.Suspend (); thread.Resume (); } Assert.IsTrue (thread.Join (1000), "#1"); } }
private void mnuItemR_Click(object sender, System.EventArgs e) { try { th = getThread(lVPrio.SelectedItems[0].Text); if(th.ThreadState==System.Threading.ThreadState.Suspended) { th.Resume(); } else { th.Start(); } } catch { } finally { loadThreads(); } }
private void btStartScan_Click(object sender, EventArgs e) { if (btStartScan.Text == "开始扫描") { for (int i = 0; i < lvwVolumes.Items.Count; i++) { if (lvwVolumes.Items[i].Checked == true) { selDriverFlag = 1; break; } } wasteTimer.Enabled = true; btStartScan.Text = "暂 停"; btCleaner.Enabled = true; btCleaner.Text = "取消扫描"; if (search_thread == null) { search_thread = new Thread(new ThreadStart(startsearch)); } if (search_thread.ThreadState == ThreadState.Stopped) { search_thread = null; search_thread = new Thread(new ThreadStart(startsearch)); } if (!search_thread.IsAlive) { search_thread.Start(); } } else { if (btStartScan.Text == "暂 停") { search_thread.Suspend(); wasteTimer.Enabled = false; btStartScan.Text = "继续扫描"; } else { if (btStartScan.Text == "继续扫描") { search_thread.Resume(); wasteTimer.Enabled = true; btStartScan.Text = "暂 停"; } else { if (btStartScan.Text == "重新扫描") { ScanResLisv.Items.Clear(); ScanFileCount = 0; for (int i = 0; i < lvwVolumes.Items.Count; i++) { if (lvwVolumes.Items[i].Checked == true) { selDriverFlag = 1; break; } } wasteTime = 0; wasteTimer.Enabled = true; btStartScan.Text = "暂 停"; btCleaner.Enabled = true; btCleaner.Text = "取消扫描"; if (search_thread == null) { search_thread = new Thread(new ThreadStart(startsearch)); } if (search_thread.ThreadState == ThreadState.Stopped) { search_thread = null; search_thread = new Thread(new ThreadStart(startsearch)); } if (!search_thread.IsAlive) { search_thread.Start(); } } } } } }
private void button3_Click(object sender, EventArgs e) { thread.Resume(); }
private static IEnumerable<StackFrame> GetStackFramesForThread(Thread thread) { StackTrace trace; switch (thread.ThreadState) { case System.Threading.ThreadState.Running: thread.Suspend(); trace = new StackTrace(thread, true); thread.Resume(); break; default: trace = new StackTrace(thread, true); break; } return trace.GetFrames(); }
/// <summary> /// Resumes a thread that has been suspended /// </summary> public void Resume() { threadField.Resume(); }
public void TestSuspend () { Thread t = new Thread (new ThreadStart (DoCount)); t.IsBackground = true; t.Start (); CheckIsRunning ("t1", t); t.Suspend (); WaitSuspended ("t2", t); CheckIsNotRunning ("t3", t); t.Resume (); WaitResumed ("t4", t); CheckIsRunning ("t5", t); t.Abort (); TestUtil.WaitForNotAlive (t, "wait13"); CheckIsNotRunning ("t6", t); }
/// <summary> /// Do our best to kill a thread, passing state info /// </summary> /// <param name="thread">The thread to kill</param> private static void Kill(Thread thread) { try { thread.Abort(); } catch (ThreadStateException) { // Although obsolete, this use of Resume() takes care of // the odd case where a ThreadStateException is received. #pragma warning disable 0618, 0612 // Thread.Resume has been deprecated thread.Resume(); #pragma warning restore 0618, 0612 // Thread.Resume has been deprecated } if ((thread.ThreadState & System.Threading.ThreadState.WaitSleepJoin) != 0) thread.Interrupt(); }