C# 多线程详解

最新推荐文章于 2024-07-18 11:38:09 发布

LST329

最新推荐文章于 2024-07-18 11:38:09 发布

阅读量1.1k

点赞数 5

分类专栏： C# 文章标签： C# 多线程进程线程

本文链接：https://blog.csdn.net/u012722551/article/details/87486200

版权

C# 专栏收录该内容

4 篇文章 1 订阅

订阅专栏

1、进程和线程的一个简单解释

SIKI学院的《第三季 SIKIC#高级教程 (2015版)》学习笔记

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）提供协调机制，一方面防止进程之间和线程之间产生冲突，另一方面允许进程之间和线程之间共享资源。

2、多线程的创建（异步委托和Thread类）

2.1 通过异步委托

创建线程的一种简单方式是定义一个委托,并异步调用它。

//一般我们会为比较耗时的操作 开启单独的线程去执行，比如下载操作
static int Test(int i, string str)
{
    Console.WriteLine("test" + i + str);
    Thread.Sleep(100);//让当前线程休眠（暂停线程的执行） 单位ms
    return 100;
}
static void Main(string[] args)
{
    //通过委托 开启一个线程
    Func<int, string, int> a = Test;
    // 开启一个新的线程去执行 a所引用的方法 
    //前面是方法的参数，后面两个null后面会有解析
    IAsyncResult ar = a.BeginInvoke(100, "LST", null, null);
    检测线程结束方法1：可判断当前线程是否执行完，返回值为bool值
    //ar.IsCompleted
    可以取得异步线程的返回值  
    //int res =a.EndInvoke(ar);
    检测线程结束方法2：1000毫秒表示超时时间，如果等待了1000毫秒 线程还没有结束的话 那么这个方法会返回false 如果在1000毫秒以内线程结束了，那么这个方法会返回true
    //bool isEnd = ar.AsyncWaitHandle.WaitOne(1000);
}

检测线程结束方法3：通过回调方法检测

//一般我们会为比较耗时的操作 开启单独的线程去执行，比如下载操作
static int Test(int i, string str)
{
    Console.WriteLine("test" + i + str);
    Thread.Sleep(100);//让当前线程休眠（暂停线程的执行） 单位ms
    return 100;
}
static void Main(string[] args)
{
    //通过委托 开启一个线程
    Func<int, string, int> a = Test;
    // 开启一个新的线程去执行 a所引用的方法 
    //前面是方法的参数
    //倒数第二个参数是一个委托类型的参数，表示回调函数，就是当线程结束的时候会调用这个委托指向的方法 倒数第一个参数用来给回调函数传递数据
    // 开启一个新的线程去执行 a所引用的方法 
    IAsyncResult ar = a.BeginInvoke(100, "LST", OnCallBack, a);
    //定义回调函数
    static void OnCallBack(IAsyncResult ar)
    {
        //转换传进来的ar参数为Func<int, string, int>类型
        Func<int, string, int> a = ar.AsyncState as Func<int, string, int>;
        //取得异步线程的返回值
        int res = a.EndInvoke(ar);
        Console.WriteLine(res + "在回调函数中取得结果");
    }
}

当然，回调函数也可以写成Lambda表达式

 a.BeginInvoke(100, "siki", ar =>
 {
     //取得异步线程的返回值
     int res = a.EndInvoke(ar);
     Console.WriteLine(res + "在lambda表达式中取得");
 }, null);

2.2 通过Thread类

对于无参数的方法

static void Test()
{
    Console.WriteLine("Test");
    Thread.Sleep(2000);
    //获取当前线程的ID
    int id = Thread.CurrentThread.ManagedThreadId
    Console.WriteLine(id + "线程结束");
}
static void Main(string[] args) 
{
    //创建出来Thread对象，这个线程并没有启动
    Thread t = new Thread(Test);
    //开始，开始去执行线程
    //在Test方法中加入Thread.CurrentThread.ManagedThreadId，可以获取当前线程的ID                  
    t.Start();
}

对于有参数的方法1：通过Start传入参数

//参数需要object类型
static void Test(object name)
{
    Console.WriteLine("Test" + name);
    Thread.Sleep(2000);
    //获取当前线程的ID
    int id = Thread.CurrentThread.ManagedThreadId
    Console.WriteLine(id + "线程结束");
}
static void Main(string[] args) 
{
    //创建出来Thread对象，这个线程并没有启动
    Thread t = new Thread(Test);
    //开始，开始去执行线程，在Start里传入参数
    t.Start("这是方法的参数");
}

对于有参数的方法2：通过构造一个类

class MyThread
{
    private string name1;
    private string name2;
    public MyThread(string Name1, string Name2)
    {
        this.name1 = Name1;
        this.name2 = Name2;
    }
    static void Test()
    {
        Console.WriteLine("Test" + name1 + name2);
        Thread.Sleep(2000);
        Console.WriteLine(id + "线程结束");
    }
}

static void Main(string[] args) 
{
    MyThread my = new MyThread("参数1","参数2");
    //我们构造一个thread对象的时候，可以传递一个静态方法，也可以传递一个对象的普通方法
    Thread t = new Thread(my.Test);
    t.Start();
}

3、线程的其他概念

3.1 后台线程和前台线程

只有一个前台线程在运行，应用程序的进程就在运行，如果多个前台线程在运行，但是Main方法结束了，应用程序的进程仍然是运行的，直到所有的前台线程完成其任务为止。
在默认情况下，用Thread类创建的线程是前台线程。线程池中的线程总是后台线程。
在用Thread类创建线程的时候，可以设置IsBackground属性，表示它是一个前台线程还是一个后台线程。
下面例子是设置Thread类创建的线程为后台线程：

class Program{
	static void Main(){
		//Thread t1 = new Thread(ThreadMain){IsBackground=false};
		//或者
		Thread t1 = new Thread(ThreadMain);
		t1.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应用程序，拼写检查器继续运行就没有意义了，在关闭应用程序的时候，拼写检查线程就可以关闭。
当所有的前台线程运行完毕，如果还有后台线程运行的话，所有的后台线程会被终止掉。

3.2 线程的优先级

线程有操作系统调度，一个CPU同一时间只能做一件事情（运行一个线程中的计算任务），当有很多线程需要CPU去执行的时候，线程调度器会根据线程的优先级去判断先去执行哪一个线程，如果优先级相同的话，就使用一个循环调度规则，逐个执行每个线程。
在Thead类中，可以设置Priority属性，以影响线程的基本优先级 ,Priority属性是一个ThreadPriority枚举定义的一个值。定义的级别有Highest ,AboveNormal,BelowNormal 和 Lowest。

3.3 控制线程

1,获取线程的状态（Running还是Unstarted,），当我们通过调用Thread对象的Start方法，可以创建线程，但是调用了Start方法之后，新线程不是马上进入Running状态，而是处于Unstarted状态，只有当操作系统的线程调度器选择了要运行的线程，这个线程的状态才会修改为Running状态。我们使用Thread.Sleep()方法可以让当前线程休眠进入WaitSleepJoin状态。
2,使用Thread对象的Abort()方法可以停止线程。调用这个方法，会在终止要终止的线程中抛出一个ThreadAbortException类型的异常，我们可以try catch这个异常，然后在线程结束前做一些清理的工作。
3,如果需要等待线程的结束，可以调用Thread对象的Join方法，表示把Thread加入进来，停止当前线程，并把它设置为WaitSleepJoin状态，直到加入的线程完成为止。

4、多线程的创建（线程池）

4.1 线程池的概念

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

4.2 通过线程池创建线程

class Program {
    static void Test(object state)
    {
        Console.WriteLine("线程开始:"+Thread.CurrentThread.ManagedThreadId);
        Thread.Sleep(2000);
        Console.WriteLine("线程结束");
    }
    static void Main(string[] args)
    {
        ThreadPool.QueueUserWorkItem(Test);//开启一个工作线程
        ThreadPool.QueueUserWorkItem(Test);
        ThreadPool.QueueUserWorkItem(Test);
        ThreadPool.QueueUserWorkItem(Test);
        ThreadPool.QueueUserWorkItem(Test);
        ThreadPool.QueueUserWorkItem(Test);
        ThreadPool.QueueUserWorkItem(Test);
        Console.ReadKey();
    }
}