You should know all about multithreading in .NET

      The timer consists of two objects: TimerCallback and Timer. The TimerCallback delegate defines methods that are executed at specified intervals, and the Timer object itself is a timer. TimerCallback will – a specific method associated with the timer. The Timer constructor (obtained by overload) requires 4 arguments. The first is the TimerCallback object specified earlier, and the second is an object that can be used to transfer the state to the specified method. The last two parameters are the time after the method is started, and the time interval after which the TimerCallback method is called. These parameters can be integer or long, representing the number of milliseconds. In the following content, the System.TimeSpan object is used, which can specify the interval in units of clock ticks, milliseconds, seconds, minutes, hours, or days.

Public class TimerExample
    {
        Private string message;//message
        Private static Timer tmr;//timer
        Private static bool complete; / / is completed
    }

The above definition is very simple, declare tmr as a static variable and apply to the entire class.

Public class TimerExample
    {
        Private string message;//message
        Private static Timer tmr;//timer
        Private static bool complete; / / is completed
        Public void GenerateText()
        {
            StringBuilder sb = new StringBuilder();
            For (int i=1;i<200;i++ )
            {
                sb.Append("This is Line"+i.ToString()+ System.Environment.NewLine);
            }
            Message = sb.ToString();
        }
        Public void GetText(object state)
        {
            If (message == null )
                Return ;
            Console.WriteLine("message is:"+ message);
            tmr.Dispose();
            Complete = true ;
        }
        Public void MainGo()
        {
            TimerExample obj = new TimerExample();
            Thread t = new Thread(new ThreadStart(GenerateText));
            t.Start();
            TimerCallback timerCallback = new TimerCallback(GetText);
            Tmr = new Timer(timerCallback,null,TimeSpan.Zero,TimeSpan.FromSeconds(2 ));
            Do
            {
                If (complete)
                    Break ;
            } while (true );
            Console.WriteLine("Exiting Main." );
            Console.ReadLine();
        }
    }

Triggered by the Timer timer once every two seconds. If the message has not been set, the method will exit, otherwise a message will be output. The timer is then removed by the GC.

Thread life cycle

When you schedule a thread, the thread goes through several states, including no startup, activation, and sleep state. The Thread class contains methods that allow startup, stop, resume, terminate, suspend, and wait for threads. Use the thread’s ThreadState to determine the current state of the thread. This state is an enumeration value, which is defined as follows.

[Flags]
    Public enum ThreadState
    {
        Running = 0 ,
        = 1 StopRequested ,
        SuspendRequested = 2 ,
        Background = 4 ,
= the Unstarted ,
= Stopped ,
        = 32 WaitSleepJoin The ,
        = 64 Suspended ,
        = 128 AbortRequested ,
        Aborted = 256 
    }

Thread method

Threads also operate four major operations, such as thread sleep, interrupt threads, suspend and resume threads, destroy threads, and connect threads. That Sleep() is not much. When the thread goes to sleep, he enters the WaitSleepJoin state. If the thread is in a sleep state, the method of waking up the thread before reaching the specified sleep time is only Interrupt(). This method will be relocated to the dispatch queue; create a ThreadInterupt.cs below. Here is the code:

Wake up thread

Public class ThreadSleppJoin
    {
        Public static Thread sleeper;
        Public static Thread worker;
        Public static void MainGo()
        {
            Console.WriteLine("Entering the void Main!" );

            Sleeper = new Thread(new ThreadStart(SleepingThread));Worker 
            = new Thread(new ThreadStart(AwakeTheThread));
            sleeper.Start();
            worker.Start();
        }
        Public static void SleepingThread()
        {
            For (int i = 1; i < 50; i++ )
            {
                Console.Write(i + " " );
                If (i == 10 || i == 20 || i == 30 )
                {
                    Console.WriteLine("Going to sleep at:" + i);
                    Thread.Sleep(20 );
                }
            }
        }
        Public static void AwakeTheThread()
        {
            For (int i = 50; i < 100; i++ )
            {
                Console.Write(i + " " );
                If (sleeper.ThreadState == System.Threading.ThreadState.WaitSleepJoin)
                {
                    Console.WriteLine("Interrupting the slepping thread" );
                    sleeper.Interrupt();
                }
            }
        }
    }

The Supend() and Resume() methods of the Thread class can be used to pause and resume threads. The Supend() method will close the thread indefinitely until another thread wakes it up. When the Resume() method is called, the thread will be in the SuspendRequested or Suspended state.

Public partial class Form1 : Form
    {
        Private Thread primeNumberThread;
        Public Form1()
        {
            InitializeComponent();
        }

        Private void button1_Click(object sender, EventArgs e)
        {
            primeNumberThread = new Thread(new ThreadStart(AddItemToListBox));
            primeNumberThread.Name = "Prime Numbers Example" ;
            primeNumberThread.Priority = ThreadPriority.BelowNormal;
            primeNumberThread.Start();
        }
        Long num = 0 ;
        Public void AddItemToListBox()
        {
            While (1==1 )
            {
                If (primeNumberThread.ThreadState != System.Threading.ThreadState.Suspended || primeNumberThread.ThreadState != System.Threading.ThreadState.SuspendRequested)
                {
                    Thread.Sleep(1000 );
                    Num += 1 ;
                    This .listBox1.Items.Add(num.ToString());
                }
                Else
                    Break ;
            }
        }

        Private void button2_Click(object sender, EventArgs e)
        {
            If (primeNumberThread.ThreadState== System.Threading.ThreadState.Running)
            {
                primeNumberThread.Suspend();
            }
        }

        Private void Form1_Load(object sender, EventArgs e)
        {
            This .Dispose();
        }

        Private void button3_Click(object sender, EventArgs e)
        {
            If (primeNumberThread.ThreadState != System.Threading.ThreadState.Suspended || primeNumberThread.ThreadState != System.Threading.ThreadState.SuspendRequested)
            {
                primeNumberThread.Resume();
            }
        }
    }

Microsoft Tip: Do not use the Suspend and Resume methods to synchronize thread activity. Is there a way to know what code to pause when executing a thread. If you hold a lock during a thread safety permission evaluation, the AppDomain in other threads may be blocked. If you suspend a thread-executing class constructor , the attempt to use the class in the AppDomain in other threads is blocked. Deadlocks can easily occur.

 Destroy thread

Private void button4_Click(object sender, EventArgs e)
        {
            primeNumberThread.Abort();
        }

Public class Threadjoining
    {
        Public static Thread SecondThread;
        Public static Thread FirstThread;
        Static void First()
        {
            For (int i=1;i<=50;i++ )
            {
                Console.Write(i+" " );
            }
        }
        Static void Second()
        {
            FirstThread.Join();
            For(int i=51;i<=100;i++ )
            {
                Console.Write(i+" " );
            }
        }
        Public static void MainGo()
        {
            FirstThread = new Thread(new ThreadStart(First));
            SecondThread = new Thread(new ThreadStart(Second));
            FirstThread.Start();
            SecondThread.Start();
        }
    }