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