C#--进程-线程

线程

线程也被称为轻量级进程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<int> numbers = new List<int>();
            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();

AppDomain （这个CLR VIA C#中有详细讲解，不过现在看不懂）

1.一个AppDomain中的代码创建的对象不能由另一个AppDomain中的代码直接访问

2.AppDomain可以卸载

3.AppDomain可以单独保护。AppDomain在创建后，会应用一个权限集，它决定了在这个AppDomain中运行的程序集的最大权限

4.AppDomain可以单独实施配置。AppDomain在创建后，会关联一组配置设置。这些设置主要影响CLR在AppDomain中加载程序集的方式。这些设置涉及搜索路径，版本绑定重定向，卷影复制及加载器优化

AppDomain vs 进程

AppDomain被创建在进程中，一个进程内可以有多个AppDomain。一个AppDomain只能属于一个进程。

2.AppDomain vs 线程

其实两者本来没什么好对比的。AppDomain是个静态概念，只是限定了对象的边界；线程是个动态概念，它可以运行在不同的AppDomain