• c#多线程同步执行

    对于多线程同步执行，可能听起来比较拗口，但是它的作用在某些业务下，有非常的大作用，分别进行阐述。

    同步

    同步就是按照顺序1234这样进行下去，有顺序，有规律的进行着。

    多线程

    多线程对于单线程来说的，单线程，就是开启一个线程进行工作，多线程则是，开启多个线程进行多个工作，并且没有顺序，没有规律性。

    多线程同步，则是，既有同步和多线程的特点，即开启多个线程进行工作的同时，还要按照顺序和规律执行。

    其实，解决多线性同步的问题，有很多种，比如使用lock锁等等方法。本节介绍使用async/await的方法来实现他的功能。

    1.建立一个winform程序，可以模拟界面处理数据

    2.使用同步的方法

    对变量a增加1，其中 Thread.Sleep(1000)可以表示，这个业务处理的时间，然后连续增加5次。

    代码

    1. using System;
    2. using System.Collections.Generic;
    3. using System.ComponentModel;
    4. using System.Data;
    5. using System.Diagnostics;
    6. using System.Drawing;
    7. using System.Linq;
    8. using System.Text;
    9. using System.Threading;
    10. using System.Threading.Tasks;
    11. using System.Windows.Forms;
    12.  
    13. namespace WindowsFormsApp1
    14. {
    15.     public partial class Form1 : Form
    16.     {
    17.         int a = 0;
    18.         public Form1()
    19.         {
    20.             InitializeComponent();
    21.         }
    22.         private  void button1_Click(object sender, EventArgs e)
    23.         {
    24.             Stopwatch stopwatch = new Stopwatch();
    25.             stopwatch.Start();
    26.             A();
    27.             //Task.Delay(3000);
    28.             //B();
    29.             //Task.Delay(3000);
    30.             //await  C();
    31.             stopwatch.Stop();
    32.             label1.Text = a.ToString();
    33.             label2.Text = "耗时：" + stopwatch.ElapsedMilliseconds;
    34.  
    35.             //Thread.Sleep(10000);
    36.         }
    37.         /// 
    38.         /// 单线程，同步有顺序
    39.         /// 
    40.         public void A()
    41.         {
    42.             a++;
    43.             Console.WriteLine(a);
    44.             Thread.Sleep(1000);
    45.  
    46.             a++; Console.WriteLine(a);
    47.             Thread.Sleep(1000);
    48.  
    49.             a++; Console.WriteLine(a);
    50.             Thread.Sleep(1000);
    51.  
    52.             a++; Console.WriteLine(a);
    53.             Thread.Sleep(1000);
    54.  
    55.             a++; Console.WriteLine(a);
    56.             Thread.Sleep(1000);
    57.         }
    58.         /// 
    59.         /// 多线程，并行，没有顺序
    60.         /// 
    61.         public void B()
    62.         {
    63.  
    64.             Task.Run(() =>
    65.             {
    66.                 a++;
    67.                 Console.WriteLine(a);
    68.                 Thread.Sleep(10000);
    69.             });
    70.             Task.Run(() =>
    71.             {
    72.                 a++;
    73.                 Console.WriteLine(a);
    74.                 Thread.Sleep(10000);
    75.             });
    76.  
    77.             Task.Run(() =>
    78.             {
    79.                 a++;
    80.                 Console.WriteLine(a);
    81.                 Thread.Sleep(10000);
    82.             });
    83.  
    84.             Task.Run(() =>
    85.             {
    86.                 a++;
    87.                 Console.WriteLine(a);
    88.                 Thread.Sleep(10000);
    89.             });
    90.             Task.Run(() =>
    91.             {
    92.                 a++;
    93.                 Console.WriteLine(a);
    94.                 Thread.Sleep(10000);
    95.             });
    96.  
    97.  
    98.             //List tasks = new List();
    99.  
    100.  
    101.             //tasks.Add(Task.Run(() =>
    102.             //{
    103.             //    a++;
    104.             //    Console.WriteLine(a);
    105.             //    Thread.Sleep(1000);
    106.             //}));
    107.  
    108.             //tasks.Add(Task.Run(() =>
    109.             //{
    110.             //    a++;
    111.             //    Console.WriteLine(a);
    112.             //    Thread.Sleep(1000);
    113.             //}));
    114.  
    115.             //tasks.Add(Task.Run(() =>
    116.             //{
    117.             //    a++;
    118.             //    Console.WriteLine(a);
    119.             //    Thread.Sleep(1000);
    120.             //}));
    121.  
    122.             //tasks.Add(Task.Run(() =>
    123.             //{
    124.             //    a++;
    125.             //    Console.WriteLine(a);
    126.             //    Thread.Sleep(1000);
    127.             //}));
    128.  
    129.             //tasks.Add(Task.Run(() =>
    130.             //{
    131.             //    a++;
    132.             //    Console.WriteLine(a);
    133.             //    Thread.Sleep(1000);
    134.             //}));
    135.  
    136.             //Task.WaitAll(tasks.ToArray());
    137.         }
    138.  
    139.         /// 
    140.         /// 多线程，并行，有顺序
    141.         /// 
    142.         /// 
    143.         public async Task C()
    144.         {
    145.             Task task = Task.Run(() =>
    146.             {
    147.                 a++;
    148.                 Console.WriteLine(a);
    149.                 Thread.Sleep(1000);
    150.             });
    151.             await task;
    152.             Task task1 = Task.Run(() =>
    153.             {
    154.                 a++;
    155.                 Console.WriteLine(a);
    156.                 Thread.Sleep(1000);
    157.             });
    158.             await task1;
    159.  
    160.             Task task2 = Task.Run(() =>
    161.             {
    162.                 a++;
    163.                 Console.WriteLine(a);
    164.                 Thread.Sleep(1000);
    165.             });
    166.             await task2;
    167.  
    168.             Task task3 = Task.Run(() =>
    169.             {
    170.                 a++;
    171.                 Console.WriteLine(a);
    172.                 Thread.Sleep(1000);
    173.             });
    174.             await task3;
    175.  
    176.             Task task4 = Task.Run(() =>
    177.             {
    178.                 a++;
    179.                 Console.WriteLine(a);
    180.                 Thread.Sleep(1000);
    181.             });
    182.             await task4;
    183.         }
    184.  
    185.  
    186.     }
    187. }

    效果

    耗时5036，按照顺序执行，并且界面是卡死状态。

    3.使用多线程的方法

    因为变化太快了，所以增加了延迟

    多线程，还可以使用B()中屏蔽的方法

    代码

    1. using System;
    2. using System.Collections.Generic;
    3. using System.ComponentModel;
    4. using System.Data;
    5. using System.Diagnostics;
    6. using System.Drawing;
    7. using System.Linq;
    8. using System.Text;
    9. using System.Threading;
    10. using System.Threading.Tasks;
    11. using System.Windows.Forms;
    12.  
    13. namespace WindowsFormsApp1
    14. {
    15.     public partial class Form1 : Form
    16.     {
    17.         int a = 0;
    18.         public Form1()
    19.         {
    20.             InitializeComponent();
    21.         }
    22.         private  void button1_Click(object sender, EventArgs e)
    23.         {
    24.             Stopwatch stopwatch = new Stopwatch();
    25.             stopwatch.Start();
    26.             //A();
    27.             Task.Delay(3000);
    28.             B();
    29.             Task.Delay(3000);
    30.             //await  C();
    31.             stopwatch.Stop();
    32.             label1.Text = a.ToString();
    33.             label2.Text = "耗时：" + stopwatch.ElapsedMilliseconds;
    34.  
    35.             //Thread.Sleep(10000);
    36.         }
    37.         /// 
    38.         /// 单线程，同步有顺序
    39.         /// 
    40.         public void A()
    41.         {
    42.             a++;
    43.             Console.WriteLine(a);
    44.             Thread.Sleep(1000);
    45.  
    46.             a++; Console.WriteLine(a);
    47.             Thread.Sleep(1000);
    48.  
    49.             a++; Console.WriteLine(a);
    50.             Thread.Sleep(1000);
    51.  
    52.             a++; Console.WriteLine(a);
    53.             Thread.Sleep(1000);
    54.  
    55.             a++; Console.WriteLine(a);
    56.             Thread.Sleep(1000);
    57.         }
    58.         /// 
    59.         /// 多线程，并行，没有顺序
    60.         /// 
    61.         public void B()
    62.         {
    63.             Task.Run(() =>
    64.             {
    65.                 a++;
    66.                 Console.WriteLine(a);
    67.                 Thread.Sleep(10000);
    68.             });
    69.             Task.Run(() =>
    70.             {
    71.                 a++;
    72.                 Console.WriteLine(a);
    73.                 Thread.Sleep(10000);
    74.             });
    75.  
    76.             Task.Run(() =>
    77.             {
    78.                 a++;
    79.                 Console.WriteLine(a);
    80.                 Thread.Sleep(10000);
    81.             });
    82.  
    83.             Task.Run(() =>
    84.             {
    85.                 a++;
    86.                 Console.WriteLine(a);
    87.                 Thread.Sleep(10000);
    88.             });
    89.             Task.Run(() =>
    90.             {
    91.                 a++;
    92.                 Console.WriteLine(a);
    93.                 Thread.Sleep(10000);
    94.             });
    95.  
    96.  
    97.             //List tasks = new List();
    98.  
    99.  
    100.             //tasks.Add(Task.Run(() =>
    101.             //{
    102.             //    a++;
    103.             //    Console.WriteLine(a);
    104.             //    Thread.Sleep(1000);
    105.             //}));
    106.  
    107.             //tasks.Add(Task.Run(() =>
    108.             //{
    109.             //    a++;
    110.             //    Console.WriteLine(a);
    111.             //    Thread.Sleep(1000);
    112.             //}));
    113.  
    114.             //tasks.Add(Task.Run(() =>
    115.             //{
    116.             //    a++;
    117.             //    Console.WriteLine(a);
    118.             //    Thread.Sleep(1000);
    119.             //}));
    120.  
    121.             //tasks.Add(Task.Run(() =>
    122.             //{
    123.             //    a++;
    124.             //    Console.WriteLine(a);
    125.             //    Thread.Sleep(1000);
    126.             //}));
    127.  
    128.             //tasks.Add(Task.Run(() =>
    129.             //{
    130.             //    a++;
    131.             //    Console.WriteLine(a);
    132.             //    Thread.Sleep(1000);
    133.             //}));
    134.  
    135.             //Task.WaitAll(tasks.ToArray());
    136.         }
    137.  
    138.         /// 
    139.         /// 多线程，并行，有顺序
    140.         /// 
    141.         /// 
    142.         public async Task C()
    143.         {
    144.             Task task = Task.Run(() =>
    145.             {
    146.                 a++;
    147.                 Console.WriteLine(a);
    148.                 Thread.Sleep(1000);
    149.             });
    150.             await task;
    151.             Task task1 = Task.Run(() =>
    152.             {
    153.                 a++;
    154.                 Console.WriteLine(a);
    155.                 Thread.Sleep(1000);
    156.             });
    157.             await task1;
    158.  
    159.             Task task2 = Task.Run(() =>
    160.             {
    161.                 a++;
    162.                 Console.WriteLine(a);
    163.                 Thread.Sleep(1000);
    164.             });
    165.             await task2;
    166.  
    167.             Task task3 = Task.Run(() =>
    168.             {
    169.                 a++;
    170.                 Console.WriteLine(a);
    171.                 Thread.Sleep(1000);
    172.             });
    173.             await task3;
    174.  
    175.             Task task4 = Task.Run(() =>
    176.             {
    177.                 a++;
    178.                 Console.WriteLine(a);
    179.                 Thread.Sleep(1000);
    180.             });
    181.             await task4;
    182.         }
    183.  
    184.  
    185.     }
    186. }

    效果 

    耗时29，可以看到没有按照顺序进行，但是界面是可以移动的

    4. 多线程同步

    这段代码就阐述了，即开启多个线程进行工作的同时，还按照顺序和规律执行。

    代码

    1. using System;
    2. using System.Collections.Generic;
    3. using System.ComponentModel;
    4. using System.Data;
    5. using System.Diagnostics;
    6. using System.Drawing;
    7. using System.Linq;
    8. using System.Text;
    9. using System.Threading;
    10. using System.Threading.Tasks;
    11. using System.Windows.Forms;
    12.  
    13. namespace WindowsFormsApp1
    14. {
    15.     public partial class Form1 : Form
    16.     {
    17.         int a = 0;
    18.         public Form1()
    19.         {
    20.             InitializeComponent();
    21.         }
    22.         private async void button1_Click(object sender, EventArgs e)
    23.         {
    24.             Stopwatch stopwatch = new Stopwatch();
    25.             stopwatch.Start();
    26.             //A();
    27.             //Task.Delay(3000);
    28.             //B();
    29.             //Task.Delay(3000);
    30.             await  C();
    31.             stopwatch.Stop();
    32.             label1.Text = a.ToString();
    33.             label2.Text = "耗时：" + stopwatch.ElapsedMilliseconds;
    34.  
    35.             //Thread.Sleep(10000);
    36.         }
    37.         /// 
    38.         /// 单线程，同步有顺序
    39.         /// 
    40.         public void A()
    41.         {
    42.             a++;
    43.             Console.WriteLine(a);
    44.             Thread.Sleep(1000);
    45.  
    46.             a++; Console.WriteLine(a);
    47.             Thread.Sleep(1000);
    48.  
    49.             a++; Console.WriteLine(a);
    50.             Thread.Sleep(1000);
    51.  
    52.             a++; Console.WriteLine(a);
    53.             Thread.Sleep(1000);
    54.  
    55.             a++; Console.WriteLine(a);
    56.             Thread.Sleep(1000);
    57.         }
    58.         /// 
    59.         /// 多线程，并行，没有顺序
    60.         /// 
    61.         public void B()
    62.         {
    63.             Task.Run(() =>
    64.             {
    65.                 a++;
    66.                 Console.WriteLine(a);
    67.                 Thread.Sleep(10000);
    68.             });
    69.             Task.Run(() =>
    70.             {
    71.                 a++;
    72.                 Console.WriteLine(a);
    73.                 Thread.Sleep(10000);
    74.             });
    75.  
    76.             Task.Run(() =>
    77.             {
    78.                 a++;
    79.                 Console.WriteLine(a);
    80.                 Thread.Sleep(10000);
    81.             });
    82.  
    83.             Task.Run(() =>
    84.             {
    85.                 a++;
    86.                 Console.WriteLine(a);
    87.                 Thread.Sleep(10000);
    88.             });
    89.             Task.Run(() =>
    90.             {
    91.                 a++;
    92.                 Console.WriteLine(a);
    93.                 Thread.Sleep(10000);
    94.             });
    95.  
    96.  
    97.             //List tasks = new List();
    98.  
    99.  
    100.             //tasks.Add(Task.Run(() =>
    101.             //{
    102.             //    a++;
    103.             //    Console.WriteLine(a);
    104.             //    Thread.Sleep(1000);
    105.             //}));
    106.  
    107.             //tasks.Add(Task.Run(() =>
    108.             //{
    109.             //    a++;
    110.             //    Console.WriteLine(a);
    111.             //    Thread.Sleep(1000);
    112.             //}));
    113.  
    114.             //tasks.Add(Task.Run(() =>
    115.             //{
    116.             //    a++;
    117.             //    Console.WriteLine(a);
    118.             //    Thread.Sleep(1000);
    119.             //}));
    120.  
    121.             //tasks.Add(Task.Run(() =>
    122.             //{
    123.             //    a++;
    124.             //    Console.WriteLine(a);
    125.             //    Thread.Sleep(1000);
    126.             //}));
    127.  
    128.             //tasks.Add(Task.Run(() =>
    129.             //{
    130.             //    a++;
    131.             //    Console.WriteLine(a);
    132.             //    Thread.Sleep(1000);
    133.             //}));
    134.  
    135.             //Task.WaitAll(tasks.ToArray());
    136.         }
    137.  
    138.         /// 
    139.         /// 多线程，并行，有顺序
    140.         /// 
    141.         /// 
    142.         public async Task C()
    143.         {
    144.             Task task = Task.Run(() =>
    145.             {
    146.                 a++;
    147.                 Console.WriteLine(a);
    148.                 Thread.Sleep(1000);
    149.             });
    150.             await task;
    151.             Task task1 = Task.Run(() =>
    152.             {
    153.                 a++;
    154.                 Console.WriteLine(a);
    155.                 Thread.Sleep(1000);
    156.             });
    157.             await task1;
    158.  
    159.             Task task2 = Task.Run(() =>
    160.             {
    161.                 a++;
    162.                 Console.WriteLine(a);
    163.                 Thread.Sleep(1000);
    164.             });
    165.             await task2;
    166.  
    167.             Task task3 = Task.Run(() =>
    168.             {
    169.                 a++;
    170.                 Console.WriteLine(a);
    171.                 Thread.Sleep(1000);
    172.             });
    173.             await task3;
    174.  
    175.             Task task4 = Task.Run(() =>
    176.             {
    177.                 a++;
    178.                 Console.WriteLine(a);
    179.                 Thread.Sleep(1000);
    180.             });
    181.             await task4;
    182.         }
    183.  
    184.  
    185.     }
    186. }

     效果

    耗时5052，并且是按照顺序执行的，而且界面还可以拖动，正是我们需要的。 

    拓展async/await

    在C()方法中，其实是遇到await后，代码则是返回task.run上面去了，然后从上到下再执行，执行到第二方法，又返回task.run上面去了，然后再从上到下执行，以此类推，所以和同步执行的时间基本上一样的。

  • 相关阅读:
    你用过 Maven Shade 插件吗？
    Spock单元测试框架介绍及在美团优选的实践___第一章
    dom的基础
    盛唐诗人三杰，儒释道的代表
    轻松实现PDF文件的在线浏览
    java毕业设计园林公司OA系统Mybatis+系统+数据库+调试部署
    Duchefa丨S0188盐酸大观霉素五水合物中英文说明书
    这3个高级前端常用的API，有你正在用的吗？
    Part 8:Pandas数据排序【Series和DataFrame的排序操作函数】
    常见的变体卷积
  • 原文地址：https://blog.csdn.net/u012563853/article/details/126168926