C#教程

关注公众号 jb51net

关闭
首页 > 软件编程 > C#教程 > C#多线程相关操作

C#多线程的相关操作讲解

作者:.NET开发菜鸟

本文详细讲解了C#多线程的相关操作,文中通过示例代码介绍的非常详细。对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下

一、线程异常

我们在单线程中,捕获异常可以使用try-catch,代码如下所示:

using System;

namespace MultithreadingOption
{
    class Program
    {
        static void Main(string[] args)
        {
            #region 单线程中捕获异常
            try
            {
                int[] array = { 1, 23, 61, 678, 23, 45 };
                Console.WriteLine(array[6]);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"message:{ex.Message}");
            }
            #endregion


            Console.ReadKey();
        }
    }
}

程序运行结果:

那么在多线程中如何捕获异常呢?是不是也可以使用try-catch进行捕获?我们先看下面的代码:

using System;
using System.Threading.Tasks;

namespace MultithreadingOption
{
    class Program
    {
        static void Main(string[] args)
        {
            #region 单线程中捕获异常
            //try
            //{
            //    int[] array = { 1, 23, 61, 678, 23, 45 };
            //    Console.WriteLine(array[6]);
            //}
            //catch (Exception ex)
            //{
            //    Console.WriteLine($"message:{ex.Message}");
            //}
            #endregion

            #region 多线程中的异常

            try
            {
                for (int i = 0; i < 30; i++)
                {
                    string str = $"main_{i}";
                    // 开启线程
                    Task.Run(() => 
                    {
                        Console.WriteLine($"{str} 开始了");
                        if(str.Equals("main_5"))
                        {
                            throw new Exception("main_5 发生了异常");
                        }
                        else if (str.Equals("main_11"))
                        {
                            throw new Exception("main_11 发生了异常");
                        }
                        else if (str.Equals("main_18"))
                        {
                            throw new Exception("main_18 发生了异常");
                        }
                        Console.WriteLine($"{str} 结束了");

                    });
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"message:{ex.Message}");
            }


            #endregion

            Console.ReadKey();
        }
    }
}

程序运行结果:

我们看到结果中并没有输出异常信息,是不是没有抛出异常呢?我们起代码进行调试,看调试信息:

我们看到程序中确实也抛出了异常,但是程序却没有捕获到,那么异常去哪里了呢?异常被多线程给吞掉了,那么如何在多线程中捕获异常呢?如果把try-catch写在线程里面呢?每一个线程都是单线程的,把try-catch写在每一个线程里面就没有意义了。在多线程中捕获异常,需要使用到WaitAll(),看下面的代码:

try
{
     // 定义一个Task类型的List集合
     List<Task> taskList = new List<Task>();
     for (int i = 0; i < 30; i++)
     {
            string str = $"main_{i}";
            // 开启线程,并把线程添加到集合中
            taskList.Add(Task.Run(() =>
            {
                 Console.WriteLine($"{str} 开始了");
                 if (str.Equals("main_5"))
                 {
                     throw new Exception("main_5 发生了异常");
                 }
                 else if (str.Equals("main_11"))
                 {
                      throw new Exception("main_11 发生了异常");
                 }
                 else if (str.Equals("main_18"))
                 {
                       throw new Exception("main_18 发生了异常");
                 }
                 Console.WriteLine($"{str} 结束了");
          }));
      }

     // 等待所有线程都执行完
     Task.WaitAll(taskList.ToArray());
}
catch (Exception ex)
{
      Console.WriteLine($"message:{ex.Message}");
}

我们用代码进行调试,调试结果:

这时就可以进入到catch里面了,我们监视ex,发现ex是AggregateException类型的异常,我们在进一步优化代码:

try
{
     // 定义一个Task类型的List集合
     List<Task> taskList = new List<Task>();
     for (int i = 0; i < 30; i++)
     {
            string str = $"main_{i}";
            // 开启线程,并把线程添加到集合中
            taskList.Add(Task.Run(() =>
            {
                 Console.WriteLine($"{str} 开始了");
                 if (str.Equals("main_5"))
                 {
                     throw new Exception("main_5 发生了异常");
                 }
                 else if (str.Equals("main_11"))
                 {
                      throw new Exception("main_11 发生了异常");
                 }
                 else if (str.Equals("main_18"))
                 {
                       throw new Exception("main_18 发生了异常");
                 }
                 Console.WriteLine($"{str} 结束了");
          }));
      }

     // 等待所有线程都执行完
     Task.WaitAll(taskList.ToArray());
}
catch(AggregateException are)
{
     foreach (var exception in are.InnerExceptions)
     {
          Console.WriteLine(exception.Message);
     }
}
catch (Exception ex)
{
      Console.WriteLine($"message:{ex.Message}");
}

最后运行程序:

我们发现这时就可以捕获到具体的异常信息了。

二、线程取消

在上面的示例中,我们捕获到了多线程中发生的异常,并且也输出了异常信息,但是这样是不友好的。在实际开发中,我们使用多线程并发执行任务,假如其中某一个任务失败了或者发生了异常,我们希望可以通知其他的线程,都停止下来,那么该如何做呢?这时就需要使用到线程取消。

Task不能外部终止任务,只能自己终止自己。

.Net框架提供了CancellationTokenSource类,该类里面有一个bool类型的属性:IsCancellationRequested,默认是false,表示是否取消线程。还提供了一个Cancel()方法,该方法可以把IsCancellationRequested的属性值设置为true,并且不能在设置回去。代码如下:

// 实例化对象
CancellationTokenSource cts = new CancellationTokenSource();

for (int i = 0; i < 20; i++)
{
      string str = $"main_{i}";
      // 开启线程
      Task.Run(() =>
      {
             try
             {
                  Console.WriteLine($"{str} 开始了");
                  // 暂停
                  Thread.Sleep(new Random().Next(50, 100) * 100);
                  if (str.Equals("main_5"))
                  {
                       throw new Exception("main_5 发生了异常");
                  }
                  else if (str.Equals("main_11"))
                  {
                        throw new Exception("main_11 发生了异常");
                  }
                  if (cts.IsCancellationRequested == false)
                  {
                        Console.WriteLine($"{str} 结束了");
                  }
                  else
                  {
                         Console.WriteLine($"{str} 线程取消");
                  }

            }
            catch (Exception ex)
            {
                   // 发生了异常,将IsCancellationRequested的值设置为true
                   cts.Cancel();
                   Console.WriteLine($"message:{ex.Message}");
            }
     });
}

程序运行结果:

可以看到,当有异常发生之后,有的线程就被取消了。这样就初步实现了线程取消。

在上面的示例中,我们是先开启了线程,如果发生了异常,则取消线程。那么会有这样一种情况:线程中发生了异常,可能这时候有的线程还没有开启,那么能不能就不让这些线程在开启呢?Task的Run方法有一个重载:

第二个参数就表示取消线程。而且CancellationTokenSource类里面正好有这个参数:

所以,我们可以利用Run方法的重载来实现不开启线程,代码如下:

try
{
    // 实例化对象
    CancellationTokenSource cts = new CancellationTokenSource();
    // 创建Task类型的集合
    List<Task> taskList = new List<Task>();
    for (int i = 0; i < 20; i++)
    {
        string str = $"main_{i}";
        // 开启线程 Task.run 以后 添加Token 就可以在某一个线程发生异常之后,让没有开启的线程不开启了
        taskList.Add(Task.Run(() =>
        {
            try
            {
                Console.WriteLine($"{str} 开始了");
                // 暂停
                Thread.Sleep(new Random().Next(50, 100) * 10);
                if (str.Equals("main_5"))
                {
                    throw new Exception("main_5 发生了异常");
                }
                else if (str.Equals("main_11"))
                {
                    throw new Exception("main_11 发生了异常");
                }
                if (cts.IsCancellationRequested == false)
                {
                    Console.WriteLine($"{str} 结束了");
                }
                else
                {
                    Console.WriteLine($"{str} 线程取消");
                }

            }
            catch (Exception ex)
            {
                // 发生了异常,将IsCancellationRequested的值设置为true
                cts.Cancel();
            }

        }, cts.Token));
    }

    // 等待所有线程执行完
    Task.WaitAll(taskList.ToArray());
}
catch (AggregateException are)
{
    foreach (var exception in are.InnerExceptions)
    {
        Console.WriteLine(exception.Message);
    }
}

程序运行结果:

输出结果中有一句话:已取消一个任务,但是我们的代码里面没有打印这句话,这是从哪里来的呢?这是因为第二个参数Token的原因,加了这个参数以后,如果就线程发生了异常,就不在继续开启线程。

三、临时变量

我们先来看看下面一段代码:

for (int i = 0; i < 20; i++)
{
    // 开启线程
    Task.Run(() =>
    {
        Task.Run(() => Console.WriteLine($"this is {i}  ThreadId: {Thread.CurrentThread.ManagedThreadId.ToString("00")}"));
    });
}

这段代码的输出结果是什么呢?我们运行程序查看结果:

可能有人会感到疑惑:为什么输出的都是20呢,而不是每次循环变量的值?这是什么原因呢。这是因为我们申请线程的时候不会发生阻塞,而且还是延迟执行的。我们知道,代码的执行速度是非常快的,循环20次几乎一瞬间就完成了,这是i就变成了20,但是线程是延迟执行的,当线程真正去执行的时候,对应的是同一个i,这时i是20,所以输出的都是20。那么该如何输出每次循环的值呢?看下面的代码:

for (int i = 0; i < 20; i++)
{
    // 定义一个新的变量
    int k = i;
    // 开启线程
    Task.Run(() =>
    {
        Task.Run(() => Console.WriteLine($"this is {i}_{k}  ThreadId: {Thread.CurrentThread.ManagedThreadId.ToString("00")}"));
    });
}

程序运行结果:

这样每次循环的时候,都重新定义变量k,保证每次都是全新的,所以k的值就是每次循环的值。

四、线程安全

什么是线程安全呢?线程安全:如果你的代码在进程中有多个线程同时运行这一段,如果每次运行的结果都跟单线程运行时的结果一致,那么就是线程安全的。

在什么情况下会出现线程安全的问题呢?

一般都是有全局变量/共享变量/静态变量/硬盘文件/数据库的值,只要多线程访问和修改,就会出现线程安全的问题。看下面的代码:

int syncNum = 0;

int AsyncNum = 0;
for (int i = 0; i < 10000; i++)
{
    syncNum++;
}
Console.WriteLine($"syncNum={syncNum}"); //单线程10000   10000

for (int i = 0; i < 10000; i++)
{
    Task.Run(() =>
    {
        AsyncNum++;
    });
}
Console.WriteLine($"AsyncNum ={AsyncNum}");

程序运行结果:

这就是线程安全造成的问题。那么该如何解决这个问题呢?这时可以使用lock关键字解决。lock关键字定义如下:

private static readonly object Form_Lock = new object();//锁对象的标准写法

修改代码如下:

int syncNum = 0;

int AsyncNum = 0;
for (int i = 0; i < 10000; i++)
{
    syncNum++;
}
Console.WriteLine($"syncNum={syncNum}");

for (int i = 0; i < 10000; i++)
{
    Task.Run(() =>
    {
        lock (Form_Lock)
        {
            AsyncNum++;
        }
    });
}
// 休眠5秒,等待所有线程都执行完毕
Thread.Sleep(5000);
Console.WriteLine($"AsyncNum ={AsyncNum}");

程序运行结果:

除了使用lock,我们还可以使用数据分拆,避免多线程操作同一个数据,这样又安全又高效。

到此这篇关于C#多线程相关操作的文章就介绍到这了。希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

您可能感兴趣的文章:
阅读全文