多线程(进阶篇&小白易懂版)

已于 2024-04-10 21:56:00 修改
阅读量1k 收藏 27
点赞数 26
分类专栏： Winform基础 21天速通 C# 文章标签： 开发语言 人工智能 .net c# AI编程 多线程 java
于 2024-04-10 21:50:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_82410658/article/details/137611851
版权

文章目录

多线程

概念：多线程就是多个线程同时工作的过程，我们可以将线程看作是程序的执行路径，每个线程都定义了一个独特的控制流，用来完成特定的任务。如果您的应用程序涉及到复杂且耗时的操作，那么使用多线程来执行是非常有益的。使用多线程可以节省 CPU 资源，同时提高应用程序的执行效率，例如现代操作系统对并发编程的实现就用到了多线程。

本篇为多线程进阶篇，使用C#语言，用winform辅助演示。多线程的基础(如线程生命周期,线程的属性和方法等)在本人C#博客有具体讲解
直达链接：link

在这里插入图片描述

为什么要有多线程

使用场景：当你有一些可能会阻塞线程（如IO操作、网络请求、复杂计算等）的操作时，可以将它们封装为线程，并使用Thread类创建子线程来异步执行它们。这样可以避免阻塞UI线程或其他重要线程，提高应用程序的响应性和性能。

具体举例比如本段代码中卖烧饼,若一名顾客要求烧饼不带芝麻，店内只有老板一个，老板骂骂咧咧得挑芝麻，此时有人再来买烧饼，只能老板挑完后才能做烧饼，这可以理解为单线程。

比如店内还有一名员工，老板则可以把这SB要求交个员工完成，直接为下名顾客服务，这可以理解为多线程。

请添加图片描述

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace _01_多线程初始
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            //
            Thread thread = Thread.CurrentThread;
            thread.Name = "主线程";
        }
        public void tzm()
        {
            Console.WriteLine($"当前任务执行在{Thread.CurrentThread}");
            Thread.Sleep(5000);
            MessageBox.Show("调好了");

        }
        private void button1_Click(object sender, EventArgs e)
        {
            tzm();
        }

        private void button2_Click(object sender, EventArgs e)
        {

            MessageBox.Show("给");
        }

        private void button3_Click(object sender, EventArgs e)
        {
            ThreadStart threadStart = new ThreadStart(tzm);
            Thread thread = new Thread(threadStart);
            thread.Name = "分";
            thread.Start();
        }
    }
}

多线程案例

案例反映：

  1. 有的错误(比如分线程操作UI报错)需要使用启动并调试才会检测到错误
  2. 从1中得出分线程不能操作UI(窗体,控件)

在这里插入图片描述

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace _02_多线程案例
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            Thread.CurrentThread.Name = "主";
        }
        void Jisun()
        {
            Console.WriteLine(Thread.CurrentThread.Name+"开始执行");
            int sum = 0;
            for (int i = 0; i < 10; i++)
            {
                Thread.Sleep(1);
                sum+=i;
            }
            //需要使用启动并调试查看错误
            //因为lable1控件是由主线程创建的，分线程不能去操作
            
            //分线程不能操作UI(窗体,控件)
        }

        private void button1_Click(object sender, EventArgs e)
        {
            Jisun();
        }

        private void button2_Click(object sender, EventArgs e)
        {
            ThreadStart threadStart = new ThreadStart(Jisun);
            Thread thread = new Thread(threadStart);
            thread.Name = "分";
            thread.Start();
        }
    }
}

代码解释

线程通讯分传主

使用场景：有耗时任务交给分线程并执行，然后在需要的时候将分线程的结果传递回主线程。

关键点提取：分传主的两个方法

较为复杂:

  1. 定义一个变量存储主线程的执行期上下文
  2. 设置变量存储当前主线程的执行期上下文
  3. 启动分线程让他执行耗时任务
  4. 分线程调用方法,给主线程传递数据
  5. 定义函数,当分线程发送数据的时候执行

简单方法: Invoke在分线程中修改UI线程(主线程)中对象的属性（下小节详讲）
在这里插入图片描述

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace _02_多线程案例
{
    public partial class Form1 : Form
    {
        //1.定义一个变量存储主线程的执行期上下文
        SynchronizationContext mainContent;
        public Form1()
        {
            InitializeComponent();
            Thread.CurrentThread.Name = "主线程";
        }
        void Fn()
        {
            Console.WriteLine(Thread.CurrentThread.Name);
            Thread.Sleep(3000);
            //4.分线程调用方法,给主线程传递数据
            mainContent.Post(Abc, "我是分线程计算的结果");
        }
        private void button1_Click(object sender, EventArgs e)
        {
            //线程通讯_主传分
            //2.设置变量存储当前主线程的执行期上下文
            mainContent = SynchronizationContext.Current;
            //ThreadStart threadStart = new ThreadStart(Fn);
            // Thread thread = new Thread(threadStart);
            //thread.Name = "分线程";
            //thread.Start();
            //启动分线程执行耗时任务
            //3.启动分线程让他执行耗时任务
            new Thread(new ThreadStart(Fn)) { Name = "分线程" }.Start();
        }
        //5.定义函数,当分线程发送数据的时候执行
        void Abc(object o)
        {
            //函数的参数就是第4步调用函数的时候传递的第二个参数
            Console.WriteLine(o);
            Console.WriteLine("Abc" + Thread.CurrentThread.Name);
            //主线程
            label1.Text = o.ToString();
        }
    }

}

代码解释

在这个示例中，有一个方法被封装为线程并执行，然后在需要的时候将计算结果传递回主线程。

  1. Fn()：这个方法模拟了一个耗时操作。它让当前线程休眠3秒，然后使用mainContent.Post()方法将计算结果传递回主线程。

在button1_Click事件处理器中，首先获取并保存了主线程的同步上下文，然后创建并启动了一个新的线程来执行Fn()方法。

线程通讯主传分

使用场景：你有一些可能会阻塞线程（如IO操作、网络请求、复杂计算等）的操作时，可以将它们封装为线程，并使用Thread类来异步执行它们。然后，在需要的时候，你可以使用Invoke()方法在UI线程中更新UI元素。这样可以避免阻塞UI线程或其他重要线程，提高应用程序的响应性和性能

本代码实例中，计算任务交给分线程，得出sum结果，需要显示在U世界界面的label1上

关键点提取：

  • new Thread(Calc) { Name = "分线程" }.Start(100);：创建一个新的线程，设置其名称为"分线程"，并立即启动它，传递参数100给Calc()方法。
  • Invoke(new Action(() => {...}))：在UI线程中执行指定的操作。
  • 如果分线程执行的任务方法要接收参数,只能接收object类型,调用Start方法的时候 传递参数即可

在这里插入图片描述

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace _03线程通讯主传分
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        private void Calc(object o)
        {
            int sum = 0;
            for (int i = 0; i < Convert.ToInt32(o); i++)
            {
                Thread.Sleep(1);
                sum += i;
            }
            //Invoke在分线程中修改UI线程(主线程)中对象的属性
            //参数是一个委托类型
            Invoke(new Action(() =>
            {
                label1.Text = $"1到{o}的和为{sum}";
            }));
        }

        private void button1_Click(object sender, EventArgs e)
        {

            //主线程
            // Calc();
            // ThreadStart 没有参数的函数类型
            //1.创建接收参数的委托
            //ParameterizedThreadStart ts = new ParameterizedThreadStart(Calc);
            2.创建线程
            //Thread thread = new Thread(ts);
            //thread.Name = "分线程";
            3.执行线程
            //thread.Start(100);//调用Start方法的时候传递参数即可

            //简写形式
            //注意:如果分线程执行的任务方法要接收参数,只能接收object类型,调用Start方法的时候 传递参数即可
            new Thread(Calc) { Name = "分线程" }.Start(100);
        }

        private void button2_Click(object sender, EventArgs e)
        {
            new Thread(Calc) { Name = "分线程" }.Start(300);
        }

        private void button3_Click(object sender, EventArgs e)
        {
            new Thread(Calc) { Name = "分线程" }.Start(200);
        }
    }
}

代码解释

在这个示例中，有一个方法被封装为线程并执行，然后在需要的时候被终止。

  1. Calc(object o)：这个方法计算从1到指定数（由参数o决定）的和，并在计算完成后更新UI元素label1的文本。

在button1_Click, button2_Click, 和 button3_Click事件处理器中，分别创建并启动了新的线程来执行Calc()方法，并传递了不同的参数。

关闭线程

使用场景：当一个线程使用完毕，需要使用手动关闭时

关键点提取：

  • new Thread(Fn)：创建一个新的线程，但不立即启动。
  • thread.Start()：启动线程。
  • thread.Abort()：终止线程。
    在这里插入图片描述
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace _04关闭线程
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        void Fn()
        {
            Thread.Sleep(1000);
            Console.WriteLine("1秒过去了");
            Thread.Sleep(1000);
            Console.WriteLine("2秒过去了");
            Thread.Sleep(1000);
            Console.WriteLine("3秒过去了");
            Thread.Sleep(1000);
            Console.WriteLine("4秒过去了");
        }
        Thread thread;
        private void button1_Click(object sender, EventArgs e)
        {
            //Start() 开启线程
            thread = new Thread(Fn);
            thread.Start();
        }

        private void button2_Click(object sender, EventArgs e)
        {
            //销毁当前执行的线程

            thread.Abort();
        }
    }
}

代码解释

在这个示例中，有一个方法被封装为线程并执行，然后在需要的时候被终止。

  1. Fn()：这个方法模拟了一个耗时操作。它让当前线程休眠4秒，并在每秒结束时打印一条消息。

在button1_Click事件处理器中，创建并启动了一个新的线程来执行Fn()方法。

在button2_Click事件处理器中，终止了上述创建的线程。

线程锁

使用场景：当有多个线程需要访问和修改同一个共享资源（如变量、数据结构、文件等）时，就需要使用线程锁来保证操作的安全性。否则，可能会出现数据竞争和不一致的问题。

关键点提取：

  1. 创建一个锁(锁一般是一个引用类型 private static readonly object key = new object();
  2. lock (key) {...}：给需要保护数据的地方加锁
  3. 使用锁的注意事项
    1. lock锁括号中使用的锁必须是引用类型，string除外
    2.推荐锁使用静态的、私有的、只读的对象
    3.我们的锁一定要保证不会被对象的外部所操作才有意义，否则就有可能被手动上锁造成死锁
    在这里插入图片描述
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace _05线程锁
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            new Thread(Fn1).Start();
            new Thread(Fn2).Start();
            new Thread(Fn3).Start();
          

        }
      
        void Fn1()
        {
            Thread.Sleep(100);
            Invoke(new Action<string>(changui), "1号线程修改的内容");
        } void Fn2()
        {
            Thread.Sleep(100);
            Invoke(new Action<string>(changui), "2号线程修改的内容");
        } void Fn3()
        {
            Thread.Sleep(100);
            Invoke(new Action<string>(changui), "3号线程修改的内容");
        }
        void changui(object o)
        {
            this.label1.Text = o.ToString();
        }
        //每次点击按钮lable都显示不同的文本,因为不同的线程执行的先后顺序不一定相同
        //执行完成的时刻也不一定相同,因此我们无法掌控某个线程执行的实际,
        // 上面是哪个线程谁都可以先执行完毕,也有可能同时执行完毕


        //1.创建一个锁(锁一般是一个引用类型)
        private static readonly object key = new object();
        
        //多个线程操作一个变量,导致我们的判断无法进行限制
        int apple;
        //使用锁的注意事项
        //1、lock锁括号中使用的锁必须是引用类型，string除外
        //2、推荐锁使用静态的、私有的、只读的对象
        //3、我们的锁一定要保证不会被对象的外部所操作才有意义，否则就有可能被手动上锁造成死锁
        private void button2_Click(object sender, EventArgs e)
        {
            apple = 1;
            new Thread(lisiEat).Start();
            new Thread(zhangsanEat).Start();
           
        }
        void zhangsanEat()
        {
            Console.WriteLine("张三吃苹果,去看看还有没有");
            //2.使用锁将代码锁起来,(互斥的,相互排斥的锁,当锁关闭的时候,另一个位置无法进入)
            lock (key)
            {
                if (apple <= 0)
                {
                    Console.WriteLine("张三:没有苹果了,不吃了");
                    return;
                }
                Thread.Sleep(100);
                apple--;
            }
            Console.WriteLine($"张三吃完了,现在还剩{apple}个苹果");
            Thread.Sleep(2000);
            Console.WriteLine("张三吃完了");
        }
        void lisiEat()
        {
            Console.WriteLine("李四吃苹果,去看看还有没有");
            lock (key)
            {
                if (apple <= 0)
                {
                    Console.WriteLine("李四:没有苹果了,不吃了");
                    return;
                }
                Thread.Sleep(100);
                apple--;
            }
            Console.WriteLine($"李四吃完了,现在还剩{apple}个苹果");
            Thread.Sleep(2000);
            Console.WriteLine("李四吃完了");
        }

      
    }
}

代码解释

在button1_Click事件处理器中，创建了三个新的线程，分别执行Fn1(), Fn2(), 和 Fn3()方法。这三个方法都会尝试修改UI元素label1的文本，但由于它们是在不同的线程中运行的，所以我们无法预测它们的执行顺序和完成时间。

在button2_Click事件处理器中，创建了两个新的线程，分别执行zhangsanEat()和lisiEat()方法。这两个方法都会尝试修改共享变量apple的值，因此需要使用线程锁来保证操作的安全性。

在这里插入图片描述

总的来说，多线程是一种强大而复杂的技术，它可以让你的程序更加响应用户输入，更有效地利用多核处理器，并同时执行多个任务。然而，多线程编程也带来了一些挑战，如数据竞争、死锁、活锁等问题。因此，你需要深入理解多线程的原理和技术，才能有效地使用它。

如果觉得文章还不错,可以点赞、收藏和转发，以支持作者继续创作更多教程。 另外本专栏将会持续更新,作者专栏中有已经更新完毕的C#基础教程!!!

2401_82410658
关注
  • 26
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java架构师进阶之路
henhenha的博客
03-30 3315
包含了计算机基础、算法和数据结构、常用工具、java核心知识、性能优化、基础框架、数据库、消息队列、缓存中间件、搜索引擎、大数据、RPC、网关、容器、面试等知识
java虚拟机多线程进阶篇总结
08-25
Java虚拟机多线程进阶篇总结是Java开发中一个非常重要的知识点，本节内容将会对Java虚拟机多线程进阶篇进行总结，帮助读者更好地理解Java虚拟机多线程的实现原理和应用。 一、线程池基本参数 在Java虚拟机中，...
Task与async/await(进阶篇&小白易懂版)
2401_82410658的博客
04-11 1933
C#中同步和异步是两种不同的编程模式，用于控制代码的执行方式。同步模式是指代码按照从上到下的顺序依次执行，在执行一个任务时会一直阻塞在那里等待其完成。而异步模式则是指在调用一个任务后立即返回，不会等待这个任务完成，而是通过回调机制在任务完成时通知调用者，可以同时执行多个任务，提高程序的效率。使用场景：当你有一些可能会阻塞线程（如IO操作、网络请求、复杂计算等）的操作时，可以将它们封装为任务，并使用Task类来异步执行它们。这样可以避免阻塞UI线程或其他重要线程，提高应用程序的响应性和性能。
面试常问集锦——多线程部分
阳阳的博客
04-01 2976
多线程 1、synchronized https://blog.csdn.net/tongdanping/article/details/79647337 synchronized锁的是什么？说说对它的理解 修饰实例方法与对象时，需要获取的是实例对象的监视器锁。 修饰静态方法与class时，需要获取的是Class对象的监视器锁。 线程a访问实例对象的同步方法，线程b访问静态同步方法时，两者不互斥。 在JDK1.6以前，使用synchronized就只有一种方式即重量级锁，而在JDK1.6以后，
python多线程是并发还是并行_Python 并发编程(一)：从性能角度理解并发编程
weixin_39821718的博客
12-18 332
1. 基本概念在开始讲解理论知识之前，先过一下几个基本概念。虽然咱是进阶教程，但我也希望写得更小白，更通俗易懂。串行：一个人在同一时间段只能干一件事，譬如吃完饭才能看电视；并行：一个人在同一时间段可以干多件事，譬如可以边吃饭边看电视；在Python中，多线程 和 协程 虽然是严格上来说是串行，但却比一般的串行程序执行效率高得很。一般的串行程序，在程序阻塞的时候，只能干等着，不能去做其他事。就好像，...
【Spring进阶系列丨第七篇】Spring框架新注解分类及详解
2401_84520245的博客
04-21 644
Bean@ScopeSystem.out.println("对象创建啦");这个Lazy注解是针对单实例Bean才有效，因为也只有单实例Bean才会默认在容器启动的时候创建对象。懒加载：容器启动不创建对象，只有在第一次使用(获取)Bean的时候采取创建对象，并初始化。该注解的作用等价于。// Window的bean// Linux的Bean// Window环境的条件// context：上下文环境// Linux环境条件@Override。
多线程详解第3讲：线程状态
D1561691的博客
04-20 678
礼让不一定成功，需要看cpu心情。
五万字15张导图Java自学路线，小白零基础入门，程序员进阶，收藏这篇就够了
热门推荐
公号：一条coding
10-12 1万+
爆肝一周
某大厂开发者对于Java多线程的总结，14-注解实现AOP
2401_84009679的博客
04-19 967
System.out.println(“更新了一个用户”);System.out.println(“查询了一个用户”);
python3进阶高级_python高级进阶
weixin_39629989的博客
12-22 400
【直播预告】蚂蚁金服高级开发工程师萧恺：IDEA 插件开发入门教程主讲人：萧恺(蚂蚁金服-支付宝事业群-高级开发工程师)本名：肖汉松讲师介绍：热爱阅读，喜欢挑战，热衷尝试新的技术，关注技术背后的原理。关注领域：Java 服务端开发，分布式系统关注语言：Java, Groovy, Python, JavaScript, Go点击关注萧恺的云栖社区个人...文章李博 bluemind2019-03-0...
java多线程进阶
10-18
这本书&ldquo;java多线程进阶&rdquo;显然旨在帮助读者深化这方面的理解，打通编程中的&ldquo;任督二脉&rdquo;，使开发者能够更加熟练地在并发环境中编写高效且稳定的代码。 1. **线程基础**：书中首先会介绍Java多线程的基础知识，包括...
Java多线程之进阶篇(一).docx
04-16
与此相反，像java所使用的这种并发系统会共享内存或I/O这样的资源，因此编程编写多线程程序最基本的困难在于，协调不同线程驱动的任务之间这些资源的使用，以便使得这些资源不会同时被多个任务访问。
Java多线程之进阶篇(二).docx
04-16
Java 多线程是Java编程中的重要组成部分，它允许程序同时执行多个任务，极大地提高了程序的效率和响应性。在Java中，实现多线程有两种主要方式：通过继承`Thread`类或者实现`Runnable`接口。然而，多线程编程不仅...
多线程终极案例程序（多线程进阶）
08-20
在IT行业中，多线程是Java编程中一个重要的高级特性，尤其对于开发高效能和响应迅速的应用至关重要。这个&ldquo;多线程终极案例程序&rdquo;旨在帮助Java开发者深化对多线程的理解，通过一个具体的&ldquo;多兵种联合攻击防御塔&rdquo;游戏...
开发语言的基本构成。
luj_1768的博客
07-24 534
许多人都对设计一套自有知识产权的开发语言感兴趣。那么，如何按照功能模块设计开发语言？
主流开发语言和开发环境介绍
weixin_44215445的博客
07-23 1335
主流开发语言和开发环境介绍
2024钉钉杯A题思路详解
最新发布
全栈川川
07-26 1494
2024钉钉杯思路
随机数种子的作用
帆的博客
07-23 1312
设置随机数种子（random seed）的目的是为了确保随机数生成器在每次运行时产生相同的随机数序列，从而保证实验结果的一致性。随机数种子通过初始化随机数生成器的内部状态，使得在相同的种子值下，随机数生成器每次调用时生成的序列是相同的。
Java多线程编程进阶与线程同步解析
&quot;Java多线程编程进阶教程&quot; 在Java编程中，多线程是一项核心技能，尤其对于处理并发任务和优化系统性能至关重要。线程允许程序同时执行多个任务，提高了应用程序的效率和响应性。理解并掌握线程的概念、使用及同步...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值