c# 多线程——入门学习

1. 概念介绍

1.1 线程

　　线程是操作系统能够进行运算调度的最小单位，包含在进程之中，是进程中的实际运作单位。一条线程指的时进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。.NET 中System.Thread下可以创建线程。

1.2 主线程

　　每个windows进程都包含一个用做程序入口点的主线程。进程入口点（main方法）中创建的第一个线程称为主线程，调用main方法时，主线程被创建。　

1.3 前台线程

　　默认情况下，Thread.Start()方法创建的线程都是前台线程，属性isBackground=true/false能够设置线程的线程是否为后台线程。前台线程能阻止应用程序的终结，只有所有的前台线程执行完毕，CLR（Common Language Runtime，公共语言运行库）才能关闭应用程序。前台线程属于工作者线程。

1.4 后台线程

　　后台线程通过isBackground设置，它不会影响应用程序的终结，当所有前台线程执行完毕后，后台线程无论是否执行完毕，都会被终结。一般后台线程用来做无关紧要的任务（如邮箱天气更新等），后台线程也属于工作者线程。

2.多线程实现

2.1 创建线程

　　在VS2019中，建立一个控制台应用程序，测试多线程服务。首先开启2个线程workThread、printThread，分别实现数字计数、打印字母。代码实现如下：

　　 class Program

    {

        static void Main(string[] args)

        {

            //新建两个线程，单独运行

            Thread workThread=new Thread(NumberCount);

            Thread printThread=new  Thread(printNumber);

            workThread.Start();

            printThread.Start();

            Console.WriteLine("Hello World!");

        }

        public static void NumberCount()

        {

            for (int i = ; i < ; i++)

            {

                Console.WriteLine("the number is {0}",i);

            }

        }

        public static void printNumber()

        {

            for (char i = 'A'; i < 'J'; i++)

            {

                Console.WriteLine("print character {0}", i);

            }

        }

    }

运行结果如下：

　　根据上述运行结果可以看出，主线程workThread和其他线程printThread运行时相互独立，互不干扰。

2.2 线程基本属性了解

　　　　static void Main(string[] args)

        {

            Thread th = Thread.CurrentThread;//访问当前正在运行的线程

            bool aliveRes=th.IsAlive;//当前线程的执行状态

            Console.WriteLine("IsAlive= {0}", aliveRes);

            th.IsBackground =false;//线程是否为后台线程

            Console.WriteLine("IsBackground= {0}", th.IsBackground);

            bool isPool= th.IsThreadPoolThread;//当前线程是否属于托管线程池

            Console.WriteLine("isPool= {0}", isPool);

            int sysbol = th.ManagedThreadId;//获取当前托管线程的唯一标识

            Console.WriteLine("ManagedThreadId= {0}", sysbol);

            ThreadPriority pry=th.Priority;//设置线程调度优先级

            Console.WriteLine("pry= {0}", pry);

            ThreadState state=th.ThreadState;//获取当前线程状态值

            Console.WriteLine("state= {0}", state);

            th.Name = "main thread";

            Console.WriteLine("this is {0}",th.Name);

            Console.ReadKey();

            Console.WriteLine("Hello World!");

        }

2.3 暂停线程

　　暂停线程通过调用sleep()方法实现，使得线程暂停但不占用计算机资源，实现代码如下：

　　　　static void NumberCountCouldDelay()

        {

            for (int i = ; i < ; i++)

            {

                Console.WriteLine("the number is {0}", i);

                Thread.Sleep(TimeSpan.FromSeconds());

            }

        }

        public static void printNumber()

        {

            for (char i = 'A'; i < 'J'; i++)

            {

                Console.WriteLine("print character {0}", i);

                Thread.Sleep(TimeSpan.FromSeconds());

            }

        }

运行结果如下：

2.4 线程池

　　线程池是一种多线程处理形式，将任务添加到队列，然后再创建线程后自动启动这些任务。通过线程池创建的任务属于后台任务，每个线程使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。如果某个线程在托管代码中空闲（如正在等待某个事件），则线程池将插入另一个辅助线程来使所有的处理器保持繁忙。

实现代码及运行结果如下：

　　　　static void Main(string[] args)

        {

            Console.WriteLine("this is main thread: ThreadId={0}", Thread.CurrentThread.ManagedThreadId);

            ThreadPool.QueueUserWorkItem(printNumber);

            ThreadPool.QueueUserWorkItem(Go);

            Console.Read();

        }

        public static void printNumber(object data)

        {

            for (char i = 'A'; i < 'D'; i++)

            {

                Console.WriteLine("print character {0}", i);

                Console.WriteLine("the print process threadId is {0}", Thread.CurrentThread.ManagedThreadId);

            }

        }

        public static void Go(object data)

        {

            Console.Write("this is another thread:ThreadId={0}",Thread.CurrentThread.ManagedThreadId);

        }

2.5 中止线程

　　线程中止采用abort方法，实现如下：

static void Main(string[] args)

        {

            ThreadStart childref = new ThreadStart(CallToChildThread);

            Console.WriteLine("In Main: Creating the child thread");

            Thread childThread = new Thread(childref);//创建线程，扩展的Thread类

            childThread.Start();//调用start()方法开始子线程的执行

            //停止主线程一段时间

            Thread.Sleep();

            //现在中止子线程

            Console.WriteLine("In Main: Abort the child thread");

            childThread.Abort();

            Console.WriteLine("Hello World!");

        }

        public static void CallToChildThread()

        {

            try

            {

                //调用abort()方法销毁线程

                Console.WriteLine("Child thread start");

                for (int counter=; counter<=;counter++)

                {

                    Thread.Sleep();

                    Console.WriteLine(counter);

                }

                Console.WriteLine("child thread abort");

            }

            catch (ThreadAbortException e)

            {

                Console.WriteLine(e);

                throw;

            }

            finally

            {

                Console.WriteLine("Couldn't catch the Thread Exception");

            }

        }

　　运行程序，出现如下错误：

　　经查找，发现.NET CORE平台不支持线程中止，在调用abort方法时会抛出ThreadAbortException异常。

2.5 跨线程访问

　　新建一个winform窗体应用程序，实现点击按钮为textbox赋值，代码如下：

 private void Button1_Click(object sender, EventArgs e)

        {

            Thread thread=new Thread(test);

            thread.IsBackground = true;

            thread.Start();

            Console.ReadLine();

        }

        private void test()

        {

            for (int i = ; i < ; i++)

            {

                this.textBox1.Text = i.ToString();

            }

        }

　　然而，运行时出现以下错误，内容显示“线程间操作无效：从不是创建控件textBox1的线程访问它”。是因为控件textBox1是由主线程创建的，thread作为另外一个线程，在.NET上执行的是托管代码，c#强制要求代码线程安全，不允许跨线程访问。

　　上述问题解决办法如下：(参考https://docs.microsoft.com/en-us/dotnet/framework/winforms/controls/how-to-make-thread-safe-calls-to-windows-forms-controls)

　　利用委托实现回调机制，回调过程如下：

　　（1）定义并声明委托；

　　（2）初始化回调方法；

　　（3）定义回调使用的方法

 public partial class UserControl1: UserControl

    {

        private delegate void SetTextboxCallBack(int value);//定义委托

        private SetTextboxCallBack setCallBack;

        /// <summary>

        ///定义回调使用的方法

        /// </summary>

        /// <param name="value"></param>

        private void SetText(int value)

        {

            textBox1.Text = value.ToString();

        }

       public UserControl1()

        {

            InitializeComponent();

        }

        private void Button1_Click(object sender, EventArgs e)

        {

            //初始化回调函数

            setCallBack=new SetTextboxCallBack(SetText);

            //创建一个线程去执行这个回调函数要操作的方法

            Thread thread = new Thread(test);

            thread.IsBackground = true;

            thread.Start();

            Console.ReadLine();

        }

        public void test()

        {

            for (int i = ; i < ; i++)

            {

                //控件上执行回调方法，触发操作

                textBox1.Invoke(setCallBack,i);

            }

        }

  }

运行结果如下：

2.5 多线程使用委托

　　线程的创建通过new Thread来实现，c#中该构造函数的实现有以下4种：

public Thread(ThreadStart start){}
public Thread(ParameterizedThreadStart start){}
public Thread(ThreadStart start, int maxStackSize){}
public Thread(ParameterizedThreadStart start, int maxStackSize){}

其中，参数ThreadStart定义为：

public delegate void ThreadStart();//无参数无返回值的委托

参数ParameterizedThreadStart 定义为：

public delegate void ParameterizedThreadStart(object obj);//有参数无返回值的委托

因此，对无返回值的委托实现如下。

2.5.1 无参数无返回值的委托

　　对于无参数无返回值的委托，是最简单原始的使用方法。Thread thread= new Thread(new ThreadStart(()=>参数)，其中参数为ThreadStart类型的委托。此类多线程代码实现如下：

class Program

    {

        public delegate void ThreadStart();//新建一个无参数、无返回值的委托

        static void Main(string[] args)

        {

            Thread thread=new Thread(new System.Threading.ThreadStart(NumberCount));

            thread.IsBackground = true;

            thread.Start();

            for (char i = 'A'; i < 'D'; i++)

            {

                Console.WriteLine("print character {0},the threadId id ={1}", i, Thread.CurrentThread.ManagedThreadId);

            }

            Console.WriteLine("Hello World!");

        }

        public static void NumberCount()

        {

            for (int i = ; i < ; i++)

            {

                Console.WriteLine("the number is {0},the threadId id ={1}", i, Thread.CurrentThread.ManagedThreadId);

            }

        }

    }

2.5.2 有参数无返回值的委托

　　对于有参数无返回值的委托，实现代码如下：

class Program

    {

        public delegate void ThreadStart(int i);//新建一个无参数、无返回值的委托

        static void Main(string[] args)

        {

            Thread thread=new Thread(new ParameterizedThreadStart(NumberCount));

            thread.IsBackground = true;

            thread.Start(3);

            for (char i = 'A'; i < 'D'; i++)

            {

                Console.WriteLine("print character {0},the threadId id ={1}", i, Thread.CurrentThread.ManagedThreadId);

            }

            Console.WriteLine("Hello World!");

        }

        public static void NumberCount(object i)

        {

           Console.WriteLine("the number is {0},the threadId id ={1}", i, Thread.CurrentThread.ManagedThreadId);

        }

    }

运行结果为：

2.5.2 有参数有返回值的委托

　　对于有参数有返回值的委托，采用异步调用实现，如下所示：

2.6 异步实现

2.6.1 Task.Result

　　..NET中引入了System.Threading.Tasks，简化了异步编程的方式，而不用直接和线程、线程池打交道。　System.Threading.Tasks中的类型被称为任务并行库（TPL)，TPL使用CLR线程池（TPL创建的线程都是后台线程）自动将应用程序的工作动态分配到可用的CPU的中。

　　Result方法可以返回Task执行后的结果。但是在.NET CORE的webapi中使用result方法来获取task的输出值，会造成当前API线程阻塞等待到task执行完成后再继续。以下代码中，get方法中的线程id-57,调用一个新线程执行task后，等待TaskCaller()执行结果（threadid=59）,待TaskCaller()方法执行完成后，原来的线程继续之后之后的语句，输出threadid=57

　　public class ValuesController:Controller

    {

        //async/await是用来进行异步调用的形式，

        [HttpGet("get")]

        public async Task<string> Get()

        {

            var info = string.Format("api执行线程{0}",Thread.CurrentThread.ManagedThreadId);//get方法中的线程

            //调用新线程执行task任务

            var infoTask = TaskCaller().Result;//调用result方法获取task的值

            var infoTaskFinished = string.Format("api执行线程(taks调用completed){0}", Thread.CurrentThread.ManagedThreadId);

            return string.Format("{0},{1},{2}", info, infoTask, infoTaskFinished);

        }

        public async Task<string> TaskCaller()

        {

            await Task.Delay();

            return string.Format("task 执行线程{0}", Thread.CurrentThread.ManagedThreadId);

        }

    }

运行结果如下：

2.6.2 Async&Await

　　c#中async关键字用来指定方法，Lambda表达式或匿名方法自动以异步的方式来调用。async/await是用来进行异步调用的形式，内部采用线程池进行管理。如果使用await，在调用await tasjCall()是不会阻塞get方法的主线程，主线程会被释放，新的线程执行完task后继续执行await后的代码，从而减少了线程切换的开销，而之前的线程则空闲了。

 public class ValuesAwaitController : Controller

    {

        [HttpGet("get")]

        public async Task<string> Get()

        {

            var info = string.Format("api执行线程{0}",Thread.CurrentThread.ManagedThreadId);//get方法中的线程

            //调用新线程执行task任务

            var infoTask = await TaskCaller();//使用await调用不会阻塞Get()中线程

            var infoTaskFinished = string.Format("api执行线程(taks调用completed){0}", Thread.CurrentThread.ManagedThreadId);

            return string.Format("{0},{1},{2}", info, infoTask, infoTaskFinished);

        }

        public async Task<string> TaskCaller()

        {

            await Task.Delay();

            return string.Format("task 执行线程{0}", Thread.CurrentThread.ManagedThreadId);

        }

    }

运行结果如下：

　　Task.result与await关键字具有类似的功能可以获取到任务的返回值，但本质上Task.result会让外层函数执行线程阻塞知道任务完成，而使用await外层函数线程不会阻塞，而是通过任务执行线程来执行await后的代码。

默认创建的Thread是前台线程，创建的Task为后台线程；
ThreadPool创建的线程都是后台线程；
任务并行库(TPL)使用的是线程池计数；
调用async标记的方法，刚开始是同步执行，只有当执行到await标记的方法中的异步任务时，才会挂起。

巴特西

c# 多线程——入门学习

最新文章

热门文章