学习C#高级编程之进程和线程

Dear 丶 2022-05-19 01:43 137阅读 0赞

1，计算机的核心是CPU，它承担了所有的计算任务。它就像一座工厂，时刻在运行。

2，如果工厂的电力有限一次只能供给一个车间使用。也就是说一个车间开工的时候，其他车间就必须停工。背后的含义就是。单个CPU一次只能运行一个任务。（多核CPU可以运行多个任务）

3，进程就好比工厂的车间，它代表CPU所能处理的单个任务。任一时刻，CPU总是运行一个进程，其他进程处于非运行状态。

4，一个车间里，可以有很多工人，他们协同完成一个任务。

5，线程就好比车间里的工人。一个进程可以包括多个线程。

6，车间的控件是工人们共享的，比如许多房间是每个工人都可以进出的。这象征一个进程的内存空间是共享的，每个线程都可以使用这些共享空间。

7，进程就好比工厂的车间，它代表CPU所能处理的单个任务。任一时刻，CPU总是运行一个进程，其他进程处于非运行状态。

8，一个防止他人进入的简单方法，就是门口加一把锁（厕所）。先到的人锁上门，后到的人看到上锁，就在门口排队，等锁打开再进去。这就叫"互斥锁"（Mutual exclusion，缩写 Mutex），防止多个线程同时读写某一块内存区域。

9，还有些房间，可以同时容纳n个人，比如厨房。也就是说，如果人数大于n，多出来的人只能在外面等着。这好比某些内存区域，只能供给固定数目的线程使用。

10，这时的解决方法，就是在门口挂n把钥匙。进去的人就取一把钥匙，出来时再把钥匙挂回原处。后到的人发现钥匙架空了，就知道必须在门口排队等着了。这种做法叫做"信号量"（Semaphore），用来保证多个线程不会互相冲突。

不难看出，mutex是semaphore的一种特殊情况（n=1时）。也就是说，完全可以用后者替代前者。但是，因为mutex较为简单，且效率高，所以在必须保证资源独占的情况下，还是采用这种设计。

11，操作系统的设计，因此可以归结为三点：

（1）以多进程形式，允许多个任务同时运行；

（2）以多线程形式，允许单个任务分成不同的部分运行；

（3）提供协调机制，一方面防止进程之间和线程之间产生冲突，另一方面允许进程之间和线程之间共享资源。

![70][]

委托方式发起线程和结束线程

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading;
    using System.Threading.Tasks;
    
    namespace _021_线程_委托方式发起线程
    {
        class Program
        {
            //一般我们会为比较耗时的操作 开启单独的线程去执行，比如下载操作
            static int Test(int i,string str)
            {
                Console.WriteLine("test"+ i + str);
                Thread.Sleep(100);//让当前线程休眠0.1秒
                return 100;
            }
            static void Main(string[] args)//在main线程中执行 一个线程里面语句的执行 是从上到下的    
            {
                //1.通过委托，开启一个线程
                //Func<int,string,int> a = Test;
                //IAsyncResult ar = a.BeginInvoke(100,"siki",null,null);//开启一个新的线程去执行a所引用的方法
                //IAsyncResult 可以取得当前线程的状态
                Console.WriteLine("main");  //先执行了mian，再输出了test;
                //while (ar.IsCompleted == false)//如果当前线程没有执行完
                //{
                //    Console.Write(".");
                //    Thread.Sleep(10);//控制线程的检测频率
                //}
                //int res = a.EndInvoke(ar);//取得异步线程的返回值
                //Console.WriteLine(res);
    
                //检测线程结束
                //bool isEnd = ar.AsyncWaitHandle.WaitOne(1000);//1000ms表示超时时间，如果等待了1000毫秒
                线程还没有结束的话，那么这个方法会返回false 如果在1000毫秒内线程结束了，那么这个方法会返回true
                //if (isEnd)
                //{
                //    int res = a.EndInvoke(ar);
                //    Console.WriteLine(res);
                //}
    
    
                //通过回调 检测线程结束
                Func<int, string, int> a = Test;
                //倒数第二个参数是一个委托类型的参数，表示回调函数，就是当线程结束的时候会调用这个委托的指向方法
                //倒数第一个参数用来给回调函数传递数据
                //IAsyncResult ar = a.BeginInvoke(100, "siki", OnCallBack, a);
    
                //使用Lambda表达式
                a.BeginInvoke(100, "siki", ar =>
                {
                    int res = a.EndInvoke(ar);
                    Console.WriteLine(res + "在Lambda表达式中取得");
                },null);
    
                Console.ReadKey();
            }
            static void OnCallBack(IAsyncResult ar)
            {
                Func<int, string, int> a = ar.AsyncState as Func<int, string, int>;
                int res = a.EndInvoke(ar);
                Console.WriteLine("子线程end"+" "+100 );
            }
        }
    }

线程的发起方式2

MyThread.cs

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading;
    using System.Threading.Tasks;
    
    namespace _022_线程_通过Thread发起线程
    {
        class MyThread
        {
            private string filename;
            private string filepath;
            public MyThread(string fileName,string filePath)
            {
                this.filename = fileName;
                this.filepath = filePath;
            }
    
            public void DownFile()
            {
                Console.WriteLine("开始下载" + filename + filepath);
                Thread.Sleep(2000);
                Console.WriteLine("下载完成");
            }
        }
    }

Program.cs

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading;
    using System.Threading.Tasks;
    
    namespace _022_线程_通过Thread发起线程
    {
        class Program
        {
            static void DownloadFile(object filename)
            {
                Console.WriteLine("开始下载:"+filename+Thread.CurrentThread.ManagedThreadId);
                Thread.Sleep(2000);
                Console.WriteLine("下载完成");
            }
            static void Main(string[] args)
            {
                //Thread t = new Thread(DownloadFile);//创建出来Thread对象，这个线程并没有启动 
                //t.Start();//开始，开始去执行线程
                //Console.WriteLine("Main");
    
                //使用Lambda表达式
                //Thread t = new Thread(() =>
                //{
                //    Console.WriteLine("开始下载:" + Thread.CurrentThread.ManagedThreadId);
                //    Thread.Sleep(2000);
                //    Console.WriteLine("下载完成");
                //});
                //t.Start();
    
                //Thread t = new Thread(DownloadFile);//创建出来Thread对象，这个线程并没有启动
                //t.Start("xxx.exe");//开始，开始去执行线程   通过start方法来传递参数
                //Console.WriteLine("Main");
    
                MyThread my = new MyThread("xxx.bt", "http://www.xxx.bbs");
                Thread t = new Thread(my.DownFile);//我们构造一个thread对象的时候，可以传递一个静态方法，也
                //可以传递一个对象的普通方法
                t.Start();
                Console.ReadKey();
            }
        }
    }

后台线程和前台线程

只有一个前台线程在运行，应用程序的进程就在运行，如果多个前台线程在运行，但是Main方法结束了，应用程序的进程仍然是运行的，直到所有的前台线程完成其任务为止。

在默认情况下，用Thread类创建的线程是前台线程。线程池中的线程总是后台线程。

在用Thread类创建线程的时候，可以设置IsBackground属性，表示它是一个前台线程还是一个后台线程。

看下面例子中前台线程和后台线程的区别：

class Program{
    
      static void Main(){
    
      var t1 = new Thread(ThreadMain){IsBackground=false};
    
      t1.Start();
    
      Console.WriteLine("Main thread ending now.");
    
      }
    
      static void ThreadMain(){
    
      Console.WriteLine("Thread +"+Thread.CurrentThread.Name+" started"); 
    
      Thread.Sleep(3000);
    
      Console.WriteLine("Thread +"+Thread.CurrentThread.Name+" started");
    
      }
    
    }

后台线程用的地方：如果关闭Word应用程序，拼写检查器继续运行就没有意义了，在关闭应用程序的时候，拼写检查线程就可以关闭。

当所有的前台线程运行完毕，如果还有后台线程运行的话，所有的后台线程会被终止掉。

//Thread t = new Thread(DownloadFile);//这个是前台线程
     Thread t = new Thread(DownloadFile);
     t.IsBackground = true;//设置为后台线程
     t.Start("xx");

线程的优先级

t.Abort();//终止这个线程的执行
    t.Join();//让当前线程睡眠，等待t线程执行完，然后继续运行下面的代码

线程池

创建线程需要时间。 如果有不同的小任务要完成,就可以事先创建许多线程 , 在应完成这些任务时发出请求。 这个线程数最好在需要更多的线程时增加,在需要释放资源时减少。

不需要 自己创建线程池，系统已经有一个ThreadPool类管理线程。 这个类会在需要时增减池中线程的线程数,直到达到最大的线程数。 池中的最大线程数是可配置的。 在双核 CPU中 ,默认设置为1023个工作线程和 1000个 I/o线程。也可以指定在创建线程池时应立即启动的最小线程数,以及线程池中可用的最大线程数。 如果有更多的作业要处理,线程池中线程的个数也到了极限,最新的作业就要排队,且必须等待线程完成其任务。

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading;
    using System.Threading.Tasks;
    
    namespace _023_线程池
    {
        class Program
        {
            //线程池中所有的线程都是后台线程，不能被修改
            static void ThreadMethod(object state)
            {
                Console.WriteLine("线程开始:"+Thread.CurrentThread.ManagedThreadId);
                Thread.Sleep(2000);
                Console.WriteLine("线程结束");
            }
            static void Main(string[] args)
            {
                ThreadPool.QueueUserWorkItem(ThreadMethod);//开启一个工作线程
                ThreadPool.QueueUserWorkItem(ThreadMethod);
                ThreadPool.QueueUserWorkItem(ThreadMethod);
                ThreadPool.QueueUserWorkItem(ThreadMethod);
                ThreadPool.QueueUserWorkItem(ThreadMethod);
                Console.ReadKey();
            }
        }
    }

线程开启的方式：任务

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading;
    using System.Threading.Tasks;
    
    namespace _024_线程_任务
    {
        class Program
        {
            static void ThreadMethod()
            {
                Console.WriteLine("任务开始");
                Thread.Sleep(2000);
                Console.WriteLine("任务结束");
            }
    
            static void Main(string[] args)
            {
                //任务相当于对线程进行了一个封装
                //Task t = new Task(ThreadMethod);//传递一个需要线程去执行的方法
                //t.Start();
    
                //TaskFactory tf = new TaskFactory();
                //tf.StartNew(ThreadMethod);
    
                Console.WriteLine("Main");
                Console.ReadKey();
            }
        }
    }

连续任务

如果一个任务t1的执行是依赖于另一个任务t2的，那么就需要在这个任务t2执行完毕后才开始执行t1。这个时候我们可以使用连续任务。

static void DoFirst(){
    	Console.WriteLine("do  in task : "+Task.CurrentId);
    	Thread.Sleep(3000);
    }
    static void DoSecond(Task t){
    	Console.WriteLine("task "+t.Id+" finished.");
    	Console.WriteLine("this task id is "+Task.CurrentId);
    	Thread.Sleep(3000);
    }
    Task t1 = new Task(DoFirst);
    Task t2 = t1.ContinueWith(DoSecond);
    Task t3 = t1.ContinueWith(DoSecond);
    Task t4 = t2.ContinueWith(DoSecond);
    
    Task t5 = t1.ContinueWith(DoError,TaskContinuationOptions.OnlyOnFaulted);

![70 1][]

任务层次结构

我们在一个任务中启动一个新的任务，相当于新的任务是当前任务的子任务，两个任务异步执行，如果父任务执行完了但是子任务没有执行完，它的状态会设置为WaitingForChildrenToComplete，只有子任务也执行完了，父任务的状态就变成RunToCompletion

static void Main(){
    	var parent = new Task(ParentTask);
    	parent.Start();
    	Thread.Sleep(2000);
    	Console.WriteLine(parent.Status);
    	Thread.Sleep(4000);
    	Console.WriteLine(parent.Status);
    	Console.ReadKey();
    }
    static void ParentTask(){
    	Console.WriteLine("task id "+Task.CurrentId);
    	var child = new Task(ChildTask);
    	child.Start();
    	Thread.Sleep(1000);
    	Console.WriteLine("parent started child , parent end");
    }
    static void ChildTask(){
    	Console.WriteLine("child");
    	Thread.Sleep(5000);
    	Console.WriteLine("child finished ");
    }

线程问题：争用条件和死锁

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading;
    using System.Threading.Tasks;
    
    namespace _025_线程问题_争用条件
    {
        class Program
        {
            static void ChangeState(object o)
            {
                MyThreadObject m = o as MyThreadObject;
                while (true)
                {
                    lock (m)//向系统申请可不可以 锁定m对象 如果m对象没有被锁定，那么可以
                        //如果m对象被锁定了，那么这个语句就会暂停，直到申请到m对象
                    {
                        m.ChangeState();//在同一时刻，只有一个线程在执行这个方法
                    }//释放对m的锁定
                }
            }
    
            static void Main(string[] args)
            {
                MyThreadObject m = new MyThreadObject();
                Thread t = new Thread(ChangeState);
                t.Start(m);
    
                new Thread(ChangeState).Start(m);
                Console.ReadKey();
            }
        }
    }

[70]: /images/20220519/739c7366c13f4f56bfd4482dd01927bc.png
[70 1]: /images/20220519/8b9031060e5f470dacab85621c13ccdb.png