07.并发编程Threads

本文主要是介绍07.并发编程Threads，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

参考文档

• https://www.cnblogs.com/springsnow/p/9409205.html#_label0

1. 基础概念

1.1 进程/线程/多线程

进程（Process）

计算机概念，程序在服务器运行时占据全部计算机资源综合指标，虚拟的数据；普通的解释就是，进程是程序的一次执行

线程（Thread）

计算机概念，进程在响应操作时最小单元，也包含CPU/内存/网络/硬盘IO，是虚拟的概念；线程可以理解为进程中的执行的一段程序片段

句柄

操作系统用来标识应用程序的某一个最小单元，比如一个窗体标识，一个按钮标识等，一个long数字，操作系统通过句柄识别应用程序，也可以通过句柄操作控件

多线程

计算机概念，一个进程有多个线程同时运行

2. C#中的线程（Thread）

在C#中，Thread类是操作线程的，是C#对线程的一个封装

说明：这种方式不是特别重要，因为此操作线程方法是.NET Framework 1.0低版本的，只做学习了解即可

2.1 构造函数

线程函数通过委托传递，可以不带参数，也可以带参数（只能有一个参数），可以用一个类或结构体封装参数

方式一，实例一个无参数，无返回值的线程对象

ThreadStart threadStart = () => Console.WriteLine("无参数无返回值委托");
Thread thread = new Thread(threadStart);
thread.Start();

方式二：实例一个有参数，无返回值的线程对象

ParameterizedThreadStart threadStart = (v) => Console.WriteLine("有参数无返回值委托：" + v);
Thread thread = new Thread(threadStart);
thread.Start("libai");

2.2 属性,方法

静态属性（常用）

实例属性（常用）

实例方法（常用）

2.3 线程等待方式

方式一：持续判断线程状态，直到线程停止

using System;
using System.Threading;

namespace th3
{
    class Program
    {
        static void Main(string[] args)
        {
            {
                ThreadStart threadStart = () => Console.WriteLine("无参数无返回值委托");
                Thread thread = new Thread(threadStart);
                
                thread.Start();

                while (thread.ThreadState != ThreadState.Stopped)
                {
                    Thread.Sleep(200);
                }
            }
        }
    }
}

方式二：Join方法

using System;
using System.Threading;

namespace th3
{
    class Program
    {
        static void Main(string[] args)
        {
            {
                ThreadStart threadStart = () => Console.WriteLine("无参数无返回值委托");
                Thread thread = new Thread(threadStart);
                
                thread.Start();
                thread.Join();  // 一直等待，直到结束
                thread.Join(3000);  // 最多等待 3000 毫秒
            }
        }
    }
}

2.4 线程状态值

// 指定的执行状态
public enum ThreadState
{
    // 启动线程
    Running = 0,
    // 正在请求线程停止，仅供内部使用
    StopRequested = 1,
    // 正在请求线程挂起
    SuspendRequested = 2,
    // 该线程将作为后台线程
    Background = 4,

    Unstarted = 8,
    // 该线程已停止
    Stopped = 16,
    // 线程将受阻
    WaitSleepJoin = 32,
    // 该线程已挂起
    Suspended = 64,

    AbortRequested = 128,

    Aborted = 256
}

2.5 线程的优先级别

.NET为线程设置Priority属性来定义线程执行的优先级别，里面包含5个选项，其中Normal是默认值，除非系统有特殊要求，否则不应该随便设置线程的优先级别；因为线程是计算机概念，执行由操作系统执行，所以这个属性只是增加优先级概率，并不一定按照设置的优先级执行

ThreadStart threadStart = () => Console.WriteLine("无参数无返回值委托");
Thread thread = new Thread(threadStart);

thread.Priority = ThreadPriority.Highest;

thread.Start();

线程优先级选项：

// 指定的调度优先级的
public enum ThreadPriority
{
    // 可以安排在具有任何其他优先级的线程之
    Lowest = 0,
    // 可以将 Thread 安排在具有 Normal 优先级的线程之后，在具有 Lowest 优先级的线程之前
    BelowNormal = 1,
    // 可以将 Thread 安排在具有 AboveNormal 优先级的线程之后，在具有 BelowNormal 优先级的线程之前
    Normal = 2,
    // 可以将 Thread 安排在具有 Highest 优先级的线程之后，在具有 Normal 优先级的线程之前
    AboveNormal = 3,
    // 可以将 Thread 安排在具有任何其他优先级的线程之前
    Highest = 4
}

2.6 线程池（ThreadPool）

概念说明

由来：在 Thread 中对线程的管理需要手动操作，在不断的开启和销毁中，存在很大的开销，为了让线程反复使用，出现了池化思想；线程池可以节省资源，控制线程总数量，防止滥用

线程池维护一个请求队列，线程池的代码从队列提取任务，然后委派给线程池的一个线程执行，线程执行完不会被立即销毁，这样既可以在后台执行任务，又可以减少线程创建和销毁所带来的开销

线程池并不是在 CLR 初始化的时候立刻创建线程的，而是在应用程序要创建线程来执行任务的时候，线程池才会初始化一个线程，初始化的线程和其他线程一样，但是在线程完成任务之后不会自行销毁，而是以挂起的状态回到线程池。当应用程序再次向现成池发出请求的时候，线程池里挂起的线程会再度激活执行任务。这样做可以减少线程创建和销毁所带来的开销

在C#中，提供了操作线程池的静态帮助类ThreadPool，并提供一些静态方法操作线程池

静态方法（常用）

代码示例

示例一：开启一个线程

using System;
using System.Threading;

namespace th3
{
    class Program
    {
        static void Main(string[] args)
        {
            ThreadPool.QueueUserWorkItem(o=>
            {
                Console.WriteLine(Thread.CurrentThread.ManagedThreadId.ToString("00"));
                Tesk();
            });

            Thread.Sleep(2000);

        }

       static void Tesk()
        {
            Console.WriteLine("开启了一个线程");
        }
    }
}

示例二：开启一个线程并传入参数

using System;
using System.Threading;

namespace th3
{
    class Program
    {
        static void Main(string[] args)
        {
            ThreadPool.QueueUserWorkItem(o =>
            {
                Console.WriteLine(Thread.CurrentThread.ManagedThreadId.ToString("00"));
                Tesk(o);
            }, "libai");

            Thread.Sleep(2000);

        }

        static void Tesk(object value)
        {
            Console.WriteLine("开启了一个线程,参数：" + value);
        }
    }
}

示例三：获取线程池中辅助线程，异步 I/O 线程的最大，最小数目

using System;
using System.Threading;

namespace th3
{
    class Program
    {
        static void Main(string[] args)
        {
            ThreadPool.GetMaxThreads(out int maxWorkerThreads, out int maxCompletionPortThreads);
            ThreadPool.GetMinThreads(out int minWorkerThreads, out int minCompletionPortThreads);

            Console.WriteLine($"辅助线程数，最大【{maxWorkerThreads}】,最小【{minWorkerThreads}】");
            Console.WriteLine($"异步I/O线程数，最大【{maxCompletionPortThreads}】,最小【{minCompletionPortThreads}】");
        }
}

示例四：设置线程池最大最小线程数（这个设置是全局的）

using System;
using System.Threading;

namespace th3
{
    class Program
    {
        static void Main(string[] args)
        {
            ThreadPool.SetMaxThreads(100, 100); // 设置最大数量时不能低于本机线程数，否则设置无效
            ThreadPool.SetMinThreads(1, 2);

            ThreadPool.GetMaxThreads(out int maxWorkerThreads, out int maxCompletionPortThreads);
            ThreadPool.GetMinThreads(out int minWorkerThreads, out int minCompletionPortThreads);

            Console.WriteLine($"辅助线程数，最大【{maxWorkerThreads}】,最小【{minWorkerThreads}】");
            Console.WriteLine($"异步I/O线程数，最大【{maxCompletionPortThreads}】,最小【{minCompletionPortThreads}】");
        }
    }
}

3. Task任务

3.1 简述说明

Task对象

Task 对象是一种的中心思想基于任务的异步模式首次引入.NET Framework 3 中，表示一个任务

System.Threading.Tasks.Task 类是Task Programming Library(TPL)中最核心的一个类

注意的是，Task里面的线程是来自线程池的

任务与线程

任务是架构在线程之上的，也就是说任务最终还是要抛给线程去执行，但是任务跟线程不是一对一的关系，比如开10个任务并不是说会开10个线程，这一点任务有点类似线程池，但是任务相比线程池有很小的开销和精确的控制

如下图所示，任务最后是托管到线程上执行的

3.2 创建方式

创建Task有三种方式，使用构造函数创建，使用Task.Run创建，使用 Task.Factory.StartNew 进行创建，这三种方式都是一样的，不过Task.Factory 是对Task进行管理，调度管理这一类的

方式一：使用构造函数创建

using System;
using System.Threading;
using System.Threading.Tasks;

namespace th3
{
    class Program
    {
        static void Main(string[] args)
        {
            Task task1 = new Task(() =>
            {
                Console.Write(Thread.CurrentThread.ManagedThreadId.ToString("00"));
            });

            task1.Start();
            Thread.Sleep(2000);
        }
    }
}

方式二：使用Task.Run创建

using System;
using System.Threading;
using System.Threading.Tasks;

namespace th3
{
    class Program
    {
        static void Main(string[] args)
        {
            Task task1 = Task.Run(() =>
            {
                Console.Write(Thread.CurrentThread.ManagedThreadId.ToString("00"));
            });

            Thread.Sleep(2000);
        }
    }
}

方式三：使用 Task.Factory.StartNew 进行创建并运行

using System;
using System.Threading;
using System.Threading.Tasks;

namespace th3
{
    class Program
    {
        static void Main(string[] args)
        {
            // 方式一：使用静态工厂属性
            {
                Task task1 = Task.Factory.StartNew(() =>
                {
                    Console.Write(Thread.CurrentThread.ManagedThreadId.ToString("00"));
                });
            }
            // 方式二：使用实例工厂
            {
                TaskFactory factory = new TaskFactory();
                Task task1 = factory.StartNew(() =>
                {
                    Console.Write(Thread.CurrentThread.ManagedThreadId.ToString("00"));
                });
            }

            Thread.Sleep(2000);
        }
    }
}

重载参数补充说明

在创建Task的时候，Task有很多的构造函数的重载，一个主要的重载就是传入TaskCreateOptions的枚举

• TaskCreateOptions.None：用默认的方式创建一个Task

• TaskCreateOptions.PreferFairness：请求scheduler尽量公平的执行Task(优先级)
• TaskCreateOptions.LongRunning：声明Task将会长时间的运行
• TaskCreateOptions.AttachToParent：因为Task是可以嵌套的，所以这个枚举就是把一个子task附加到一个父task中

3.3 属性,方法

实例属性（常用）

实例方法（常用）

静态方法（常用）

代码示例

示例一：WaitAny，WaitAll方法示例（结果会受计算机性能影响，建议执行多次）

using System;
using System.Threading;
using System.Threading.Tasks;

namespace th3
{
    class Program
    {
        static void Main(string[] args)
        {
            {
                Task task1 = new Task(() =>
                {
                    Thread.Sleep(2000);
                    Console.Write(Thread.CurrentThread.ManagedThreadId.ToString("00"));
                });
                Task task2 = new Task(() =>
                {
                    Thread.Sleep(2000);
                    Console.Write(Thread.CurrentThread.ManagedThreadId.ToString("00"));
                });
                task1.Start();
                task2.Start();

                Task.WaitAny(task1, task2);

                Console.WriteLine("执行完成WaitAny");
                Thread.Sleep(2000);
            }
            Console.WriteLine("============================================");
            {
                Task task1 = new Task(() =>
                {
                    Thread.Sleep(2000);
                    Console.Write(Thread.CurrentThread.ManagedThreadId.ToString("00"));
                });
                Task task2 = new Task(() =>
                {
                    Thread.Sleep(2000);
                    Console.Write(Thread.CurrentThread.ManagedThreadId.ToString("00"));
                });
                task1.Start();
                task2.Start();

                Task.WaitAll(task1, task2);

                Console.WriteLine("执行完成WaitAll");
                Thread.Sleep(2000);
            }
        }
    }
}

using System;
using System.Threading;
using System.Threading.Tasks;

namespace th3
{
    class Program
    {
        static void Main(string[] args)
        {
            {
                Task task1 = new Task(() =>
                {
                    Thread.Sleep(3000);
                    Console.Write(Thread.CurrentThread.ManagedThreadId.ToString("00"));
                });
                Task task2 = new Task(() =>
                {
                    Thread.Sleep(2000);
                    Console.Write(Thread.CurrentThread.ManagedThreadId.ToString("00"));
                });
                task1.Start();
                task2.Start();

                Task.WaitAny(task1, task2);
                Console.WriteLine("有一个执行结束");
                Task.WaitAll(task1, task2);
                Console.WriteLine("全部执行结束");
            }
        }
    }
}

3.4 常用示例

1. 示例：连续任务

所谓的延续的Task就是在第一个Task完成后自动启动下一个Task，参数为上次Task的引用

示例一：单个连续任务

using System;
using System.Threading;
using System.Threading.Tasks;

namespace th3
{
    class Program
    {
        static void Main(string[] args)
        {
            {
                Task task1 = new Task(() =>
                {
                    Thread.Sleep(2000);
                    Console.Write(Thread.CurrentThread.ManagedThreadId.ToString("00"));
                });
                Task task2 = new Task(() =>
                {
                    Thread.Sleep(1000);
                    Console.Write(Thread.CurrentThread.ManagedThreadId.ToString("00"));
                });

                task1.ContinueWith(t=>
                {
                    task2.Start();
                });

                task1.Start();

                Thread.Sleep(5000);
            }
        }
    }
}

示例二：多个连续任务

using System;
using System.Threading;
using System.Threading.Tasks;

namespace th3
{
    class Program
    {
        static void Main(string[] args)
        {
            var SendTask = Task.Factory.StartNew(() => Console.WriteLine("无参数"))
                            .ContinueWith<bool>(s => { return true; })
                            .ContinueWith<string>(r =>
                            {
                                Console.WriteLine(r.Result);
                                return "libai";
                            });
            Console.WriteLine(SendTask.Result);
        }
    }
}

2. 示例：任务结果

示例一：单个任务结果

using System;
using System.Threading.Tasks;

namespace th3
{
    class Program
    {
        static void Main(string[] args)
        {
            // 方式一
            {
                Task<int> task = new Task<int>(()=> { return 1; });
            	task.Start();
            	Console.WriteLine(task.Result);
            }
            // 方式二
            {
                Task<int> task = Task.Run<int>(()=> { return 1; });
            	Console.WriteLine(task.Result);
            }
        }
    }
}

3.5 线程同步

所谓同步：是指在某一时刻只有一个线程可以访问变量

c#为同步访问变量提供了一个非常简单的方式，即使用c#语言的关键字Lock，它可以把一段代码定义为互斥段，互斥段在一个时刻内只允许一个线程进入执行，而其他线程必须等待

关键字Lock定义

• expression代表你希望跟踪的对象：
  • 如果你想保护一个类的实例，一般地，你可以使用this
  • 如果你想保护一个静态变量（如互斥代码段在一个静态方法内部），一般使用类名就可
  • 如果需要锁变量，推荐使用 object类型
• statement_block就算互斥段的代码，这段代码在一个时刻内只可能被一个线程执行

Lock(expression)
{
   statement_block
}

示例代码

namespace T1
{
    class Program
    {
        static void Main(string[] args)
        {
            BookShop book = new BookShop();
            //创建两个线程同时访问Sale方法
            Thread t1 = new Thread(new ThreadStart(book.Sale));
            Thread t2 = new Thread(new ThreadStart(book.Sale));
            //启动线程
            t1.Start();
            t2.Start();
            Console.ReadKey();
        }
    }
    class BookShop
    {
        //剩余图书数量
        public int num = 1;
        public void Sale()
        {
            //使用lock关键字解决线程同步问题
            lock (this)
            {
                int tmp = num;
                if (tmp > 0)//判断是否有书，如果有就可以卖
                {
                    Thread.Sleep(1000);
                    num -= 1;
                    Console.WriteLine("售出一本图书，还剩余{0}本", num);
                }
                else
                {
                    Console.WriteLine("没有了");
                }
            }
        }
    }
}

4. async/await

.NET 4.5版本时，C#提供Async和Await关键字（语法糖）来实现异步编程，两者是一组关键子，通常一起使用

Async是用来修饰方法，Await在方法内部，只能方法Async修饰的方法内或者Task前面

作用：用同步方法的思维写异步方法，提高了内存占用率

官方介绍

• await 运算符暂停对封闭 async方法的求值，直到其操作数表示的异步操作完成

• 异步操作完成后，await 运算符将返回操作的结果（如果有）

• 当 await 运算符应用到表示已完成操作的操作数时，它将立即返回操作的结果，而不会暂停封闭的方法

• await 运算符不会阻止计算异步方法的线程

• 若某个函数F的函数体中需要使用await关键字的函数必须以async标记

4.1 代码示例

示例一：执行顺序

using System;
using System.Threading;
using System.Threading.Tasks;

namespace th4
{
    class Program
    {
        static void Main(string[] args)
        {
            Show();
            Console.ReadKey();
        }

        static void Show()
        {
            Console.WriteLine("1\t" + Thread.CurrentThread.ManagedThreadId.ToString("00")); // 1.首先执行主线程
            Async();    // 2.2.调用后返回主线程
            Console.WriteLine("2\t" + Thread.CurrentThread.ManagedThreadId.ToString("00")); // 3.主线程执行
        }
        static async void Async()
        {
            Console.WriteLine("5\t" + Thread.CurrentThread.ManagedThreadId.ToString("00")); // 2.1.按照顺序执行，也是主线程
            await Task.Run(() =>    // 4.开启子线程执行，使用await等待完成
            {
                Thread.Sleep(200);
                Console.WriteLine("3\t" + Thread.CurrentThread.ManagedThreadId.ToString("00")); // 5.子线程执行
            });
            Console.WriteLine("4\t" + Thread.CurrentThread.ManagedThreadId.ToString("00")); // 6.等待子线程完成后执行
        }
    }
}

5. 扩展补充

5.1 为什么可以多线程

1. 多个CPU的核可以并行工作，几核几线程，这里的线程指的是模拟核并行；多核之间叫并行

2. CPU分片，1秒的处理能力分成1000份，操作系统调度着去响应不同的任务，从宏观角度来说，感觉就是多个任务在并行执行，从微观角度来说，一个物理CPU同一时刻只能为一个任务服务，并发：CPU分片的并发

5.2 同步异步特点

可等待

同步方法：主线程（UI线程）忙于计算，无暇其它（卡界面）

异步多线程方法：主线程闲置，计算任务交给子线程完成（不卡界面）

执行速度

同步方法：慢，因为只有一个线程计算

异步多线程方法：快，因为多个线程并发计算，CPU利用率高（密集型计算），以资源换性能

执行顺序

同步方法：有序执行

异步多线程方法：启动无序，线程资源是向操作系统申请的，由操纵系统的调度策略决定，所以启动顺序随机；同一个任务同一个线程，执行时间也不确定，CPU分片结束也无序

5.3 如何实现线程有序执行？

控制线程执行顺序有四种方法可实现

方法一：使用委托回调，回调方法是在子线程中执行

using System;

namespace th2
{
    class Program
    {
        static void Main(string[] args)
        {
            Action<string> action = Tesk1;
            action.Invoke("libai");
            Console.WriteLine("end");

            AsyncCallback callback = re =>
            {
                Console.WriteLine("end");
            };
            action.BeginInvoke("zhaoyun",callback,null);

        }
        static void Tesk1(string key)
        {
            Console.WriteLine("start:" + key);
        }
    }
}

5.4 线程/进程的区别

• 进程间是独立的，这表现在内存空间，上下文环境；

  线程运行在进程空间内，进程包含线程（包含关系）

• 进程是无法突破进程存取其他进程内的存储空间；

  而线程由于处于进程空间内，所以同一进程所产生的线程共享同一内存空间。

• 同一进程中的两段代码不能够同时执行，除非引入线程

• 线程是属于进程的，当进程退出时该进程所产生的线程都会被强制退出并清除

5.5 前台线程,后台线程

通过设置线程的IsBackground属性，设置线程为前台或后台线程，通常用在WinFrom程序

using System;
using System.Threading;

namespace th3
{
    class Program
    {
        static void Main(string[] args)
        {
            {
                ThreadStart threadStart = () => Console.WriteLine("无参数无返回值委托");
                Thread thread = new Thread(threadStart);

                thread.IsBackground = true;     // 后台线程，进程结束，线程结束
                thread.IsBackground = false;    // 前台线程，进程结束，等待线程执行结束

                thread.Start();
            }
        }
    }
}

6. 应用示例

6.1 示例一：封装线程回调

需求：封装一个方法，当子线程执行结束后，调用回调方法

思路：首先肯定是需要一个子线程来执行的，其次回调方法必须是线程要执行的内容结束后调用；所以可以在其外部加一层，因为子线程是不卡主线程的，可以在子线程内部依次等待调用

using System;
using System.Threading;

namespace th3
{
    class Program
    {
        static void Main(string[] args)
        {
            {
                ThreadStart threadStart = () =>
                {
                    Console.WriteLine("开始执行");
                    Thread.Sleep(2000);
                };
                Action action = () =>
                {
                    Console.WriteLine("执行结束");
                };

                ThreadWithCallBack(threadStart, action);
            }
        }

        static void ThreadWithCallBack(ThreadStart threadStart, Action callback)
        {
            ThreadStart start = () =>
            {
                threadStart.Invoke();
                callback.Invoke();
            };
            Thread thread = new Thread(start);
            thread.Start();
        }
    }
}

这篇关于07.并发编程Threads的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！