线程基础之创建,暂停,等待，锁

using System;
using System.Threading;
using static System.Console;//语法糖 使用static #6.0特性 让我们可以访问类型的静态成员
 

namespace Chapter1.Recipe1
{
    class Program
    {
        static void Main(string[] args)
        {
            //1.创建线程,执行循环打印DelayPrint()
            //2.之后立马执行PrintNumber()
            //3.但是 DelayPrint() 加入了Sleep 使线程处在休眠状态  占用CPU时间少 所以会先执行PrintNumbers() 
            Thread t = new Thread(DelayPrint);
            t.Start();//Start：线程开始
            PrintNumbers();


            //加入Join就避免了先执行PrintNumbers方法 DelayPrint没打印完成之前 Main不会往下走
            Thread t1 = new Thread(DelayPrint);
            t1.Start();//Start：线程开始
            t1.Join();//Join:线程等待
            PrintNumbers();
        }
      
        static void PrintNumbers()
        {
            WriteLine("Starting1...");
            for (int i = 1; i < 10; i++)
            {  //循环打印输入1-10
                WriteLine(i);
            }
        }
        //延迟打印
        static void DelayPrint()
        {
            WriteLine("Starting2...");
            for (int i = 0; i <= 10; i++)
            {
                Thread.Sleep(TimeSpan.FromSeconds(2));//线程暂停
                WriteLine(i);
            }
        }
    }
}

using System;
using System.Threading;
using static System.Console;
using static System.Threading.Thread;

namespace Chapter1.Recipe5
{
    class Program
    {
        static void Main(string[] args)
        {
            WriteLine("Starting program 开始程序...");
            Thread t = new Thread(PrintNumbersWithStatus);//创建线程t 打印当前线程状态
    
            t.Start();
        
        
            for (int i = 1; i < 100; i++)
            {//在执行 Sleep之前县城是Running运行状态 执执行之后就可以获取到线程处于WaitSleepJoin等待状态
                WriteLine(t.ThreadState.ToString());
            }
        
             
            WriteLine("A thread has been aborted 这个线程是已经终止的");
            WriteLine(t.ThreadState.ToString()+"最后1");
        
        }

        
        //打印第几个线程状态状态
        static void PrintNumbersWithStatus()
        {
            WriteLine("Starting...开始");
            WriteLine(CurrentThread.ThreadState.ToString());
            for (int i = 1; i < 10; i++)
            {
                Sleep(TimeSpan.FromSeconds(2));
                WriteLine(i);
            }
        }
    }
}

using System;
using System.Threading;
using static System.Console;
using static System.Threading.Thread;
using static System.Diagnostics.Process;

namespace Chapter1.Recipe6
{
    class Program
    {
        static void Main(string[] args)
        {
            WriteLine($"Current thread priority 当前线程优先级: {CurrentThread.Priority}");
        
            RunThreads();
            Sleep(TimeSpan.FromSeconds(2));
            WriteLine("Running on a single core在单个CPU上运行");
            GetCurrentProcess().ProcessorAffinity = new IntPtr(1);//让操作系统运行在单个CPU上 得到优先级或高的线程会计算更多
            RunThreads();
        }
        //执行两个线程 设置优先级并让他们各自迭代 两秒后暂停所有线程并得到迭代数字
        static void RunThreads()
        {
            var sample = new ThreadSample();

            var threadOne = new Thread(sample.CountNumbers);
            threadOne.Name = "ThreadOne";
            var threadTwo = new Thread(sample.CountNumbers);
            threadTwo.Name = "ThreadTwo";

            threadOne.Priority = ThreadPriority.Highest;  

            threadTwo.Priority = ThreadPriority.Lowest;
            threadOne.Start();
            threadTwo.Start();

            Sleep(TimeSpan.FromSeconds(2));
            sample.Stop();
        }

        class ThreadSample
        {
            private bool _isStopped = false;

            public void Stop()
            {
                _isStopped = true;
            }

            public void CountNumbers()
            {
                long counter = 0;

                while (!_isStopped)
                {
                    counter++;
                }

                WriteLine($"{CurrentThread.Name} with " +
                    $"{CurrentThread.Priority,11} priority " +
                    $"has a count = {counter,13:N0}");
            }
        }
    }
}

1：为什么要使用锁(Lock)：

　　1，多个线程共享一个资源,必须保证当前线程使用该资源的时候,所以其他线程需要等待当前线程完成操作

　　2，使用Lock来实现这种行为,但是使用之后其他线程将会处于阻塞状态,这也会带来性能问题,

　　3，lock其实就是Monitor类的一个语法糖

　　4，使用try/catch块的时候 不要在线程外捕获异常,捕获不到, 应该在编写线程的代码块中捕获异常