using System;
using System.Threading;

namespace MultiThreadDemo
{
    class Program
    {
        public static void threadfunc()
        {
            try
            {
                Console.WriteLine("Child thread starts");
                Thread.Sleep(1000);
            }
            catch (ThreadAbortException / *ex* /)
            {
                Console.WriteLine("Thread abort!");
            }
        }

        static void Main(string[] args)
        {
            ThreadStart func = new ThreadStart(threadfunc);
            Thread th = new Thread(func);

            th.Start();
            Thread.Sleep(500);

            th.Abort();

            Console.ReadLine();
        }
    }
}

using System;
using System.Threading;

// The ThreadWithState class contains the information needed for
// a task, and the method that executes the task.
//
public class ThreadWithState
{
    // State information used in the task.
    private string boilerplate;
    private int numberValue;

    // The constructor obtains the state information.
    public ThreadWithState(string text, int number)
    {
        boilerplate = text;
        numberValue = number;
    }

    // The thread procedure performs the task, such as formatting
    // and printing a document.
    public void ThreadProc()
    {
        Console.WriteLine(boilerplate, numberValue);
    }
}

// Entry point for the example.
//
public class Example
{
    public static void Main()
    {
        // Supply the state information required by the task.
        ThreadWithState tws = new ThreadWithState(
            "This report displays the number {0}.", 42);

        // Create a thread to execute the task, and then
        // start the thread.
        Thread t = new Thread(new ThreadStart(tws.ThreadProc));
        t.Start();
        Console.WriteLine("Main thread does some work, then waits.");
        //t.Join();
        //Console.WriteLine(
        //    "Independent task has completed; main thread ends.");
    }
}
// The example displays the following output:
//       Main thread does some work, then waits.
//       This report displays the number 42.
//       Independent task has completed; main thread ends.

using System;
using System.Threading;

// The ThreadWithState class contains the information needed for
// a task, the method that executes the task, and a delegate
// to call when the task is complete.
//
public class ThreadWithState
{
    // State information used in the task.
    private string boilerplate;
    private int numberValue;

    // Delegate used to execute the callback method when the
    // task is complete.
    private ExampleCallback callback;

    // The constructor obtains the state information and the
    // callback delegate.
    public ThreadWithState(string text, int number,
        ExampleCallback callbackDelegate)
    {
        boilerplate = text;
        numberValue = number;
        callback = callbackDelegate;
    }

    // The thread procedure performs the task, such as
    // formatting and printing a document, and then invokes
    // the callback delegate with the number of lines printed.
    public void ThreadProc()
    {
        Console.WriteLine(boilerplate, numberValue);
        Thread.Sleep(3000);
        if (callback != null)
            callback(1);
    }
}

// Delegate that defines the signature for the callback method.
//
public delegate void ExampleCallback(int lineCount);

// Entry point for the example.
//
public class Example
{
    public static void Main()
    {
        // Supply the state information required by the task.
        ThreadWithState tws = new ThreadWithState(
            "This report displays the number {0}.",
            42,
            new ExampleCallback(ResultCallback)
        );

        Thread t = new Thread(new ThreadStart(tws.ThreadProc));

        / *
            默认情况，在新开启一个子线程的时候，他是前台线程，只有，将线程的IsBackground属性设为true;他才是后台线程
            当子线程是前台线程，则主线程结束并不影响其他线程的执行，只有所有前台线程都结束，程序结束
            当子线程是后台线程，则主线程的结束，会导致子线程的强迫结束
         * /
        t.IsBackground = true;

        t.Start();
        Console.WriteLine("Main thread does some work, then waits.");
        t.Join();
        Console.WriteLine(
            "Independent task has completed; main thread ends.");
    }

    // The callback method must match the signature of the
    // callback delegate.
    //
    public static void ResultCallback(int lineCount)
    {
        Console.WriteLine(
            "Independent task printed {0} lines.", lineCount);
    }
}
// The example displays the following output:
//       Main thread does some work, then waits.
//       This report displays the number 42.
//       Independent task printed 1 lines.
//       Independent task has completed; main thread ends.

using System;
using System.Threading;

public class Work
{
    public static void Main()
    {
        // Start a thread that calls a parameterized static method.
        Thread newThread = new Thread(Work.DoWork);
        newThread.Start(42);

        // Start a thread that calls a parameterized instance method.
        Work w = new Work();
        newThread = new Thread(w.DoMoreWork);
        newThread.Start("The answer.");

        Console.ReadLine();
    }

    public static void DoWork(object data)
    {
        Console.WriteLine("Static thread procedure. Data='{0}'", data);
    }

    public void DoMoreWork(object data)
    {
        Console.WriteLine("Instance thread procedure. Data='{0}'", data);
    }
}
// This example displays output like the following:
//       Static thread procedure. Data='42'
//       Instance thread procedure. Data='The answer.'

using System;
using System.Threading;

public class Example
{
    static Thread thread1, thread2;

    public static void Main()
    {
        thread1 = new Thread(ThreadProc);
        thread1.Name = "Thread1";
        thread1.Start();

        thread2 = new Thread(ThreadProc);
        thread2.Name = "Thread2";
        thread2.Start();


        Console.ReadLine();
    }

    static TimeSpan waitTime = new TimeSpan(0, 0, 2);
    private static void ThreadProc()
    {
        Console.WriteLine("\nCurrent thread: {0}", Thread.CurrentThread.Name);
        if (Thread.CurrentThread.Name == "Thread1" &&
            thread2.ThreadState != ThreadState.Unstarted)
            //thread2.Join();
            //if (thread2.Join(2000))
            //if (thread2.Join(waitTime))
            if (thread2.Join(TimeSpan.FromSeconds(2)))
                Console.WriteLine("Thread2 has termminated.");
            else
                Console.WriteLine("The timeout has elapsed and Thread1 will resume.");

        Thread.Sleep(4000);
        Console.WriteLine("\nCurrent thread: {0}", Thread.CurrentThread.Name);
        Console.WriteLine("Thread1: {0}", thread1.ThreadState);
        Console.WriteLine("Thread2: {0}\n", thread2.ThreadState);
    }
}
// The example displays output like the following:
//       Current thread: Thread1
//       
//       Current thread: Thread2
//       
//       Current thread: Thread2
//       Thread1: WaitSleepJoin
//       Thread2: Running
//       
//       
//       Current thread: Thread1
//       Thread1: Running
//       Thread2: Stopped

using System;
using System.Security.Permissions;
using System.Threading;

class ThreadInterrupt
{
    static void Main()
    {
        StayAwake stayAwake = new StayAwake();
        Thread newThread =
            new Thread(new ThreadStart(stayAwake.ThreadMethod));
        newThread.Start();

        Thread.Sleep(500);
        // The following line causes an exception to be thrown 
        // in ThreadMethod if newThread is currently blocked
        // or becomes blocked in the future.
        newThread.Interrupt();
        Console.WriteLine("Main thread calls Interrupt on newThread.");

        // Tell newThread to go to sleep.
        stayAwake.SleepSwitch = true;

        // Wait for newThread to end.
        newThread.Join();


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

class StayAwake
{
    bool sleepSwitch = false;

    public bool SleepSwitch
    {
        set { sleepSwitch = value; }
    }

    public StayAwake() { }

    public void ThreadMethod()
    {
        Console.WriteLine("newThread is executing ThreadMethod.");
        while (!sleepSwitch)
        {
            // Use SpinWait instead of Sleep to demonstrate the 
            // effect of calling Interrupt on a running thread.
            Thread.SpinWait(60000000);  // 只是让CPU去执行一段没有用的代码。当时间结束之后继续执行其它代码，而不是重新参与CPU的竞争。
        }
        try
        {
            Console.WriteLine("newThread going to sleep.");

            // When newThread goes to sleep, it is immediately 
            // woken up by a ThreadInterruptedException.
            Thread.Sleep(Timeout.Infinite); // 是强制放弃CPU的时间片，然后重新和其他线程一起参与CPU的竞争。
        }
        catch (ThreadInterruptedException e)
        {
            Console.WriteLine("newThread cannot go to sleep - " +
                "interrupted by main thread.");
        }
    }
}

using System;
using System.Threading;

class Test
{
    public static void Main()
    {
        Thread newThread = new Thread(new ThreadStart(TestMethod));
        newThread.Start();
        Thread.Sleep(1000);

        // Abort newThread.
        Console.WriteLine("Main aborting new thread.");
        newThread.Abort("Information from Main.");  //可为异常类提供异常信息

        // Wait for the thread to terminate.
        newThread.Join();
        Console.WriteLine("New thread terminated - Main exiting.");
    }

    static void TestMethod()
    {
        try
        {
            while (true)
            {
                Console.WriteLine("New thread running.");
                Thread.Sleep(1000);
            }
        }
        catch (ThreadAbortException abortException)
        {
            Console.WriteLine((string)abortException.ExceptionState);
        }
    }
}

using System;
using System.Threading;

namespace InterlockedExchange_Example
{
    class MyInterlockedExchangeExampleClass
    {
        //0 for false, 1 for true.
        private static int usingResource = 0;

        private const int numThreadIterations = 5;
        private const int numThreads = 3;

        static void Main()
        {
            Thread myThread;
            Random rnd = new Random();

            for (int i = 0; i < numThreads; i++)
            {
                myThread = new Thread(new ThreadStart(MyThreadProc));
                myThread.Name = String.Format("Thread{0}", i + 1);

                //Wait a random amount of time before starting next thread.
                Thread.Sleep(rnd.Next(0, 1000));
                myThread.Start();
            }

            Console.ReadLine();
        }

        private static void MyThreadProc()
        {
            for (int i = 0; i < numThreadIterations; i++)
            {
                UseResource();

                //Wait 1 second before next attempt.
                Thread.Sleep(1000);
            }
        }

        //A simple method that denies reentrancy.
        static bool UseResource()
        {
            //0 indicates that the method is not in use.
            if (0 == Interlocked.Exchange(ref usingResource, 1))
            {
                Console.WriteLine("{0} acquired the lock", Thread.CurrentThread.Name);

                //Code to access a resource that is not thread safe would go here.

                //Simulate some work
                Thread.Sleep(500);

                Console.WriteLine("{0} exiting lock", Thread.CurrentThread.Name);

                //Release the lock
                Interlocked.Exchange(ref usingResource, 0);
                return true;
            }
            else
            {
                Console.WriteLine("   {0} was denied the lock", Thread.CurrentThread.Name);
                return false;
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;

namespace WaitAndPulse
{
    public class LockMe
    {
    }

    class WaitPulse1
    {
        private int result = 0;
        private LockMe lM;

        public WaitPulse1()
        {
        }

        public WaitPulse1(LockMe l)
        {
            this.lM = l;
        }

        public void CriticalSection()
        {
            Monitor.Enter(this.lM);

            Console.WriteLine("WaitPulse1: Entered Thread "
                + Thread.CurrentThread.GetHashCode());

            //Thread.Sleep(1500);

            for (int i = 1; i <= 5; i++)
            {
                Monitor.Wait(this.lM);

                Console.WriteLine("WaitPulse1: WokeUp");
                Console.WriteLine("WaitPulse1: Result = "
                    + result++
                    + " ThreadID "
                    + Thread.CurrentThread.GetHashCode());

                Monitor.Pulse(this.lM);
            }
            Console.WriteLine("WaitPulse1: Exiting Thread "
                + Thread.CurrentThread.GetHashCode());

            Monitor.Exit(this.lM);
        }
    }

    class WaitPulse2
    {
        private int result = 0;
        private LockMe lM;

        public WaitPulse2()
        {
        }

        public WaitPulse2(LockMe l)
        {
            this.lM = l;
        }

        public void CriticalSection()
        {
            // 在指定对象上获取排他锁
            Monitor.Enter(this.lM);
          
            Console.WriteLine("WaitPulse2: Entered Thread "
                + Thread.CurrentThread.GetHashCode());

            for (int i = 1; i <= 5; i++)
            {
                // 通知等待队列中的线程锁定对象状态的更改
                // 目的是为了让另外一个线程中的Wait不阻塞
                Monitor.Pulse(this.lM);

                Console.WriteLine("WaitPulse2: Result = "
                    + result++
                    + " ThreadID "
                    + Thread.CurrentThread.GetHashCode());
               
                // 释放对象上的锁并阻止当前的线程,直到它重新获取该锁
                Monitor.Wait(this.lM);

                Console.WriteLine("WaitPulse2: WokeUp");
            }
            Console.WriteLine("WaitPulse2: Exiting Thread "
                + Thread.CurrentThread.GetHashCode());

            // 释放指定对象上的排他锁
            Monitor.Exit(this.lM);
        }
    }

    public class ClassForMain
    {
        public static void Main(string[] args)
        {
            LockMe l = new LockMe();

            WaitPulse1 e1 = new WaitPulse1(l);
            WaitPulse2 e2 = new WaitPulse2(l);

            Thread t1 = new Thread(new ThreadStart(e1.CriticalSection));
            t1.Start();

            Thread.Sleep(200);

            Thread t2 = new Thread(new ThreadStart(e2.CriticalSection));
            t2.Start();

            //Wait till the user enters something
            Console.ReadLine();
        }
    }
}

//-------------------------------------------------------------------------------------
//  Monitor
//  线程优先顺序： 【拥有锁线程】> 【就绪队列】> 【等待队列】
//-------------------------------------------------------------------------------------

using System;
using System.Threading;
using System.Diagnostics;
using System.Collections;

public class ProgramMain
{
    const int MAX_LOOP_TIME = 10;
    private static Queue m_smpQueue = new Queue();
    private static object obj = new object();

    public class ThreadFunc
    {
        /// <summary>
        /// 将要处理的数据放入队列
        /// </summary>
        public void ThreadAFunc()
        {
            int count = 0;
            lock(obj)
            {
                Monitor.Pulse(obj);
                while (count < MAX_LOOP_TIME)
                {
                    Trace.WriteLine("ThreadA WriteLine");
                    m_smpQueue.Enqueue(count);

                    // 等待ThreadB处理数据!
                    // (当前线程释放同步锁；当前线程转入【等待队列】，直到当前线程再次转到【就绪队列】并再次获取锁才继续 否则一直阻塞)
                    Monitor.Wait(obj);
                    
                    // 让【等待队列】中的线程转入【就绪队列】(一旦当前线程不再拥有锁，就绪队列中的线程可以拥有锁）
                    Monitor.Pulse(obj);

                    count++;
                }
            }
        }

        /// <summary>
        /// 处理队列中数据
        /// </summary>
        public void ThreadBFunc()
        {
            lock (obj)
            {
                do
                {
                    if(m_smpQueue.Count > 0)
                    {
                        // 数据处理
                        int count = (int)m_smpQueue.Dequeue();
                        Console.WriteLine(count.ToString());
                        Trace.WriteLine("ThreadB WriteLine");
                        //Thread.Sleep(3000);
                    }
                    // 让【等待队列】中的线程转入【就绪队列】
                    Monitor.Pulse(obj);
                } while (Monitor.Wait(obj, 10000));   // 等待数据入队列（当前线程释放锁）
            }
        }
    }

    public static void Main(string[] args)
    {
        ThreadFunc a = new ThreadFunc();

        Thread ta = new Thread(new ThreadStart(a.ThreadAFunc));
        Thread tb = new Thread(new ThreadStart(a.ThreadBFunc));

        ta.Start();
        tb.Start();

        //Console.ReadLine();
    }
}