线程

线程也被称为轻量级进程lightweight process ，LWP，线程是CPU独立调度和分派的基本单位，同一个进程中的多个线程将共享该进程中的全部系统资源，多线程共享堆heap资源，c#程序默认有一个主线程，辅助线程 worker thread ，与主线程一起执行任务，辅助线程主要做计算操作，IO线程主要做输入输出的操作

进程

process进程类，程序与进程没有一一对应关系，进程是程序在计算机市的一次执行活动，进程可以分为用户进程和系统进程，进程可以分为用户进程和系统进程，同一个进程中的uoge线程有各自的调用栈(call stack）,自己的寄存器环境(register context）

进程与线程的关系

进程与线程池关系：每个进程一个线程池ThreadPool

单线程

只有一个线程的程序，什么时候用单线程比较好：计算密集型的操作，因为CPU的分片操作会浪费计算时间，一次算完比较快

多线程

线程池

为什么会有线程池？为了优化线程创建和销毁的资源消耗，创建和销毁影响程序性能

LOCK

lock(x)，x需要是一个对象，是全局变量

首先要明白为什么上面这段话能够锁定代码，其中的奥妙就是X这个对象，事实上X是任意一种引用类型，它在这儿起的作用就是任何线程执行到lock(X)时候，X需要独享才能运行下面的代码，若假定现在有3个线程A,B,C都执行到了lock(X)而ABC因为此时都占有X，这时ABC就要停下来排个队，一个一个使用X，从而起到在下面的代码块内只有一个线程在运行(因为此时只有一个线程独享X，其余两个在排队)，所以这个X必须是所有要执行临界区域代码进程必须共有的一个资源，从而起到抑制线程的作用。

lock关键字可以用来确保代码块完成运行而不被其他线程中断。语句以lock开头，在参数后面还有一个只能由一个线程执行的代码块。

lock 是一个语法糖，lock等于monitor+异常处理，lock=安全的monitor，lock关键字就是用monitor类来实现的

Monitor类

1.Monitor类可以防止多个线程同时执行代码块

2.Monitor方法允许一个且仅一个线程继续执行后面的语句，其他所有线程都将被阻止，直到执行语句的线程调用Exit

3.这与使用lock关键字一样，事实上，lock关键字就是用monitor类来实现的

Object ss= new Object();

Monitor.Enter(ss);

try { // 需要执行的代码 }

finally{ Monitor.Exit(ss);} // 退出线程锁定

waitHandle.waitone

waitHandle.waitany

waitHandle.waitall

创建线程 Thread ThreadStart

class Program    {        const int res = 1000;        static void Main(string[] args)        {            ThreadStart threadstart = DoWork;            Thread thread = new Thread(threadstart);            thread.Start();            for (int i = 0; i < res; i++)            {                Console.Write("-");            }            thread.Join();   //              Console.ReadKey();        }        static void DoWork()        {            for (int i = 0; i < res; i++)            {                Console.Write("+");            }        }//1.其中thread.Join()方法会造成当前进程（主进程）等待，直到其他正在执行的进程结束//2.thread.IsBackGround = true; 将当前进程设置为后台进程//3.thread.Priority = ThreadPriority.Highest ; 将进程的优先级设置为最高级（当然还有其他枚举值）//4.Console.WriteLine(thread.ThreadState) 输出当前进程的状态/                public static void CallToChildThread()        {            Console.WriteLine("Child thread starts");        }        public static void CallToParentThread()        {            Console.WriteLine("Parent thread starts");        }        static void Main(string[] args)        {            ThreadStart childref = new ThreadStart(CallToChildThread);     //  创建线程的委托，并将需要调用的方法赋给委托            childref += CallToParentThread;    // 赋值新的方法给委托            Console.WriteLine("In Main: Creating the Child thread");            Thread childThread = new Thread(childref);            childThread.Start();            Console.ReadKey();        }

锁定线程

class Program        {            static List
    
      numbers = new List
     
      ();            static object locker = new object();            static void Main(string[] args)            {                numbers.Add(0);                Thread t1 = new Thread(GetNum);                t1.Start();                Thread t2 = new Thread(SetNum);                t2.Start();                Console.ReadKey();            }            static void GetNum()            {                lock (locker)                {                    Console.WriteLine("t1->" + numbers[0]);  // -> 0                    Thread.Sleep(1000);                    Console.WriteLine("t1->" + numbers[0]); // -> 0                }            }            static void SetNum()            {                lock (locker)                {                    numbers[0] = 2;                    Console.WriteLine("t2->" + numbers[0]); // ->2                }            }        }    }

管理线程 Thread.Sleep()

Console.WriteLine("this is a sleep function test");            Thread.Sleep(5000);            Console.WriteLine("this is new thread function");//注意：避免在正式的生产代码中使用Sleep()函数//1.没有参数就是没有延迟时间设置，相当于没有写//2.使用sleep(时间设定值)来同步的程序被成为”穷人的同步“

终止线程 Thread.Abort()

ThreadStart ts = new ThreadStart(Speak);                       Thread aa = new Thread(ts);            aa.Start();            aa.Abort();            ts += Speak2;            aa.Start();      //  这个会报错，因为已经被终止的线程无法再开启// 注意：避免在正式的生产代码中使用Abort()函数，因为可能造成不可预测的结果，造成程序不稳定

ThreadPool线程池

如果池中的现场都被长时间运行或者I/O受限的工作占用了，正在排队的工作必然会延迟。所以在高性能程序设计的时候，这个ThreadPool和Thread只作为实现细节使用

const int res = 1000;        static void Main(string[] args)        {            ThreadPool.QueueUserWorkItem(DoWork,"sss");   //  可以加个逗号传参数进去             for (int i = 0; i < res; i++)            {                Console.Write("-");            }            Console.ReadKey();        }        static void DoWork(object ss)   // 方法的参数必须是一个，且只能是可以转换为object的类型        {            for (int i = 0; i < res; i++)            {                Console.Write("+");            }        }

TPL ( Task Parallel Library ) 任务并行库

有长时间运行或者I/O受限的工作的需求时，使用TPL构建高级抽象。

1.TPL提供了一个能代表异步工作的对象，还提供了相应的API以便与工作进行交互。

（类比委托，委托封装了方法，但它是同步的）

Task

Task.Run方法

Task.Wait方法

Task tt = Task.Run(                () =>                {                    for (int count = 0; count < res; count++)                    {                        Console.Write("-");                    }                }                );             tt.Wait();                   //  当前线程等待tt线程结束后再执行            // Task.WaitAll(tt);         //  另一种写法            for (int i = 0; i < res; i++)            {                Console.Write("+");            }            Console.ReadKey();

Task.ContiuneWith()方法

Console.WriteLine("Before");            Task task1 = Task.Run(                () => { Console.WriteLine("Start with ....."); }                ).ContinueWith((a) => { Console.WriteLine("continuing A ....."); });   // 这里面的的a其实是Task a，大概是方便lambda内部的函数调用吧            Task task2 = task1.ContinueWith(                (a) => { Console.WriteLine("continuing B ....."); }                );            Task task3 = task1.ContinueWith(                (a) => { Console.WriteLine("continuing C ....."); }                );            Task.WaitAll(task2, task3);            Console.WriteLine("Finsihed");            Console.ReadKey();