C#--线程的基本操作

最新推荐文章于 2024-06-04 08:15:00 发布
最新推荐文章于 2024-06-04 08:15:00 发布
阅读量1k 收藏 5
点赞数
分类专栏： VS-C# 文章标签： python c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43069920/article/details/119758536
版权

文章目录

创建线程

在C#中创建线程时，首先需要创建一个ThreadStart委托实例，再以这个ThreadStart委托作为为参数，来构造Thread实例。
注意：Thread类拥有四种重载的构造函数，常用的一个函数接收一个ThreadStart类型的参数，而ThreadStart是一个委托，其语法格式如下：

public delegate void ThreadStart()

线程休眠

线程的休眠是通过Thread类的Sleep方法实现的，而Thread类的实例的IsAlive属性可以判断线程是否执行完毕。Sleep方法有以下两种重载形式。
（1）将当前线程挂起指定的毫秒数，语法格式如下：

public static void Sleep (int millisecondsTimeout)

millisecondsTimeout：线程被阻止的毫秒数。如果该参数的值为零，则该线程会将其时间的剩余部分让给任何已经准备好运行的、具有同等优先级的线程，否则会无限期阻止线程。
（2）将当前线程挂起指定的时间，语法格式如下：

public static void Sleep (TimeSpan timeout)

timeout：线程被阻止的时间量的TimeSpan。
编写程序，创建线程，并在运行时休眠5秒。

using System;
using System.Threading;
namespace Text
{
    class Program
    {
        //下面的实例演示了 sleep() 方法的使用，用于在一个特定的时间暂停线程。
        public static void Method()
        {
            Console.WriteLine("启动线程");
            // 线程暂停 5000 毫秒
            int t = 5000;
            Console.WriteLine("线程暂停 {0} 秒",
                              t / 1000);
            Thread.Sleep(t);
            Console.WriteLine("线程恢复");
        }
        static void Main(string[] args)
        {
            ThreadStart ts = new ThreadStart(Method);
            Thread th = new Thread(ts);//创建线程
            th.Start();  //启动线程
            Console.ReadKey();
        }
    }
}

【程序分析】本例演示了线程的休眠。在代码中，首先用户可以自定义一个静态的void方法Method；然后在Main方法中，创建ThreadStart委托的实例ts；接着通过ts构造Thread类的实例th，这样就创建好一个线程；最后通过Start方法，启动线程，由于在Method方法中调用了Sleep方法，使线程休眠5秒后再运行。

启动线程
线程暂停 5 秒
线程恢复

线程的挂起与恢复

Suspend方法用于挂起线程，Resume方法用于继续执行已经挂起的线程。可以使用这两个方法进行线程的同步，和Start方法有些类似的是，在调用Suspend方法后不会立即停止，而是执行到一个安全点后挂起。

  1. Suspend方法
    挂起线程，或者如果线程已挂起，则不起作用，语法格式如下：
public void Suspend();
  1. Resume方法
    继续已挂起的线程，语法格式如下：
public void Resume();

编写程序，自定义两个线程，主线程（MainThread方法）和工作线程（WorkThread方法），主线程倒序输出，工作线程正序输出。先完成主线程，再完成工作线程。

using System;
using System.Threading;

namespace ThreadExample
{
    class Program
    {
        static void Main(string[] args)
        {
            ThreadStart entry = new ThreadStart(CalcSum);
            Thread workThread = new Thread(entry);
            workThread.Start();
            workThread.Suspend();//挂起线程(改动部分)
            CalcGap();
            workThread.Resume();//恢复线程（改动部分）
            Console.ReadKey();

        }

        static void CalcSum()
        {
          
            for (long i = 0; i < 1000000000; i++)
            {               
                if (i % 100000000 == 0 && i != 0)
                {
                    Console.WriteLine("workThread-->i={0}", i);
                }
            }
        }

        static void CalcGap()
        {
            long gap = 0;
            for (long i = 1000000000; i >= 0; i--)
            {
                gap = i ;
                if (i % 100000000 == 0 && i != 0)
                {
                    Console.WriteLine("MainThread-->i={0}:gap={1}", i, gap);
                }
            }
        }
    }
}

【程序分析】本例演示了线程的挂起与恢复。在代码中，用户定义了两个方法WorkThread和MainThread。MainThread方法用于倒序输出0～10；WorkThread方法用于正序输出1～9；然后在Main方法中，创建ThreadStart委托的实例work；接着通过work构造Thread类的实例th，这样就创建好一个线程；最后通过Start方法，启动线程。挂起线程使用Suspend方法。线程被挂起后，操作被停止或进入休眠状态。因此，从结果中可以看出，此时主线程正常执行，但是工作线程WorkThread没有被执行。那么要想工作线程能继续执行，就需要使用Resume方法恢复线程。

MainThread-->i=1000000000:gap=1000000000
MainThread-->i=900000000:gap=900000000
MainThread-->i=800000000:gap=800000000
MainThread-->i=700000000:gap=700000000
MainThread-->i=600000000:gap=600000000
MainThread-->i=500000000:gap=500000000
MainThread-->i=400000000:gap=400000000
MainThread-->i=300000000:gap=300000000
MainThread-->i=200000000:gap=200000000
MainThread-->i=100000000:gap=100000000
workThread-->i=100000000
workThread-->i=200000000
workThread-->i=300000000
workThread-->i=400000000
workThread-->i=500000000
workThread-->i=600000000
workThread-->i=700000000
workThread-->i=800000000
workThread-->i=900000000

终止线程

线程的终止是通过Thread类的Abort方法和Join方法来实现的。

  1. Abort方法
    当一个线程执行时间太长时，用户有可能要终止这个线程，这就要使用Abort方法。该方法有两种重载方式：
public void Abort() //终止进程
public void Abort(Object stateInfo)

参数stateInfo是一个对象，包含应用程序特定的信息（如状态），该信息可供正被终止的线程使用
注意：在线程调用Abort方法时，会引发ThreadAbortException异常。如果没有捕获异常，线程将会终止通过。
编写程序，启动线程，while循环5次后终止线程。

using System;
using System.Threading;
namespace Project5
{
    class Program
    {
        static void Main(string[] args)
        {
            ThreadStart work = new ThreadStart(WorkThread);   //创建工作线程
            Thread th = new Thread(work);
            th.Start();    //启动线程           
            int i = 0;
            while (th.IsAlive)
            {
                i++;
                Thread.Sleep(500);
                if (i == 5)
                {
                    th.Abort();  //线程被终止
                    Console.WriteLine("\r\n线程被终止");
                }
            }
            Console.ReadKey();
        }
        static void WorkThread()
        {
            for (long i = 0; i < 1000000000; i++)
            {
                if (i % 100000000 == 0 && i != 0)
                {
                    Console.WriteLine("工作线程WorkThread-->i={0}", i);
                }
            }
        }
    }
}

【程序分析】本例演示了线程的终止。在代码中，用户首先自定义方法WorkThread，用于输出一组数据；然后在Main方法中，创建ThreadStart委托的实例work；接着通过work构造Thread类的实例th，这样就创建好一个线程；最后通过Start方法，启动工作线程。中止线程使用Abort方法。线程被中止，就停止运行，是无法恢复的，因为Windows会永久地删除被中止线程的所有数据。跟挂起工作线程时的结果一样，中止工作线程后，工作线程自然不会被执行。

工作线程WorkThread-->i=100000000
工作线程WorkThread-->i=200000000

线程被终止
  1. Join方法
    Join方法用于等待线程中止，如果后续的处理依赖于另一个已经终止的线程，可以调用Join方法，等待线程中止。该方法有三种重载形式：
public void Join() 
public void Join(int millisecondsTimeout)
public void Join(TimeSpan timeout)

参数说明：millisecondsTimeout表示等待线程终止的毫秒数。如果线程已终止，则返回值为true，如果线程经过了millisecondsTimeout指定时间后未终止，返回值为false。timeout表示等待线程终止的时间量TimeSpan。如果线程已终止，则返回值为true，如果线程经过timeout时间量之后未终止，则返回值为false。
编写程序，使用Join方法等待线程终止。

using System;
using System.Threading;
namespace Project
{
    class Program
    {
        static void Main(string[] args)
        {
            ThreadStart work = new ThreadStart(WorkThread);   //创建工作线程
            Thread th = new Thread(work);
            th.Start();    //启动线程
            //th.Join();
            th.Join(1000);//等待工作线程中止（修改代码）
            MainThread();
        }
        static void WorkThread()
        {
            for (long i = 1; i < 1000000000; i++)
            {
                if (i % 100000000 == 0 && i != 0)
                {
                    Console.WriteLine("工作线程WorkThread-->i={0}", i);
                }
            }
            Console.WriteLine("工作线程执行完毕");
        }
        static void MainThread()
        {
            long gap = 0;
            for (long i = 1000000000; i >= 0; i--)
            {
                gap = i - 1;
                if (i % 100000000 == 0)
                {
                    Console.WriteLine("主线程  MainThread-->i={0}", i);
                }
            }
            Console.WriteLine("主线程执行完毕");
            Console.ReadKey();
        }
    }
}

【程序分析】本例演示了线程的等待终止。在Main方法中，工作线程调用了Join方法，因此，需待工作线程中止后，主线程才会被执行。Join的其他重载方法可以指定等待的时间期限，超过了这个时间期限，程序也会继续执行。因此，可以将“th.Join();”语句修改为“th.Join(1000);”。

工作线程WorkThread-->i=100000000
工作线程WorkThread-->i=200000000
工作线程WorkThread-->i=300000000
工作线程WorkThread-->i=400000000
工作线程WorkThread-->i=500000000
工作线程WorkThread-->i=600000000
工作线程WorkThread-->i=700000000
工作线程WorkThread-->i=800000000
工作线程WorkThread-->i=900000000
工作线程执行完毕
主线程  MainThread-->i=1000000000
主线程  MainThread-->i=900000000
主线程  MainThread-->i=800000000
主线程  MainThread-->i=700000000
主线程  MainThread-->i=600000000
主线程  MainThread-->i=500000000
主线程  MainThread-->i=400000000
主线程  MainThread-->i=300000000
主线程  MainThread-->i=200000000
主线程  MainThread-->i=100000000
主线程  MainThread-->i=0
主线程执行完毕

主线程  MainThread-->i=1000000000
工作线程WorkThread-->i=100000000
工作线程WorkThread-->i=200000000
主线程  MainThread-->i=900000000
工作线程WorkThread-->i=300000000
主线程  MainThread-->i=800000000
工作线程WorkThread-->i=400000000
主线程  MainThread-->i=700000000
工作线程WorkThread-->i=500000000
主线程  MainThread-->i=600000000
工作线程WorkThread-->i=600000000
主线程  MainThread-->i=500000000
工作线程WorkThread-->i=700000000
主线程  MainThread-->i=400000000
工作线程WorkThread-->i=800000000
主线程  MainThread-->i=300000000
工作线程WorkThread-->i=900000000
工作线程执行完毕
主线程  MainThread-->i=200000000
主线程  MainThread-->i=100000000
主线程  MainThread-->i=0
主线程执行完毕

线程的优先级

线程的优先级可以通过Thread类的Priority属性设置，Priority属性是一个ThreadPriority型枚举，列举了5个优先等级：AboveNormal、BelowNormal、Highest、Lowest、Normal。普通线程的优先级默认为Normal；如果想有更高的优先级，可设置为AboveNormal或Highest；如果想有较低的优先级，可设置为BelowNormal或Lowest。线程优先级值，从高到低按顺序如下表所示。
在这里插入图片描述
可以通过调用线程的Priority属性来获取和设置其优先级。Priority属性用来获取或设置一个值，该值指示线程的调度优先级。
编写程序，分别创建两个线程，然后通过设定不同的优先级来显示线程的名称和优先级。

using System;
using System.Threading;
namespace Project7
{
    class Program
    {
        public static void method()
        {
            //输出线程的名称
            Console.WriteLine("线程名称：{0}",Thread.CurrentThread.Name.ToString());
            //输出线程的优先级
            Console.WriteLine("线程的优先级：{0}",Thread.CurrentThread.Priority.ToString());
        }
        static void Main(string[] args)
        {
            ThreadStart ts1 = new ThreadStart(method);
            ThreadStart ts2 = new ThreadStart(method);
            Thread t1 = new Thread(ts1);
            Thread t2 = new Thread(ts2);
            //为两个线程命名
            t1.Name = "学习C#线程一";
            t2.Name = "学习Java线程二";
            //指定线程t1的优先级为Highest
            t1.Priority = ThreadPriority.Highest;
            //启动两个线程
            t1.Start();
            t2.Start();
            Console.ReadKey();
        }    
    }
}

【程序分析】本例演示了线程的优先级。在代码中用户自定义方法method，用于输出线程的名称和优先级；然后在Main方法中，创建两个线程t1和t2，首先使用Name属性为两个线程命名，再使用Priority属性设置线程t1的优先级为Highest，最后启动两个线程。通过最后的输出结果发现，t1的优先级值为Highest，t2的优先级值为Normal，这是因为Normal是线程的默认值。

线程名称：学习C#线程一
线程的优先级：Highest
线程名称：学习Java线程二
线程的优先级：Normal
菩提树下祈愿的少年
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C#版线程-倒计时
07-20
在C#编程中，线程是程序执行的基本单元，它允许程序同时执行多个任务，极大地提高了效率。在“C#版线程-倒计时”这个主题中，我们将深入探讨如何利用C#来实现一个倒计时功能，这对于初学者来说是一个很好的实践项目...
C#内存释放-线程控制-线程启动-线程暂停
12-20
`Thread`类是最基本的线程对象，用于创建和执行新的线程。线程启动通常是通过`Thread.Start()`方法完成的，这使得新线程开始执行其`ThreadStart`委托所指向的方法。线程的暂停则相对复杂，因为线程的暂停和恢复并不...
c#: 线程状态和管理之线程的休眠、挂起和中断
火焰
03-15 1万+
环境： window 10 .netcore 3.1.1 vs2019 16.4.5 一、线程的状态 线程的状态可以从枚举ThreadState中查看到： public enum ThreadState { Running = 0x0, StopRequested = 0x1, SuspendRequested = 0x2, Background = 0x4, ...
c# 并发与异步 一、线程创建 汇合 休眠 阻塞
学以致用 知行合一
01-19 1477
线程是抢占式的。它的执行和其他线程的代码是交错执行的。这个术语通常可以解释一些由此而产生的问题。 线程一旦启动，其IsAlive属性就会返回true，直至线程停止。当Thread的构造函数接收的委托执行完毕之后，线程就会停止。线程停止之后就无法再启动了。 每一个线程都有一个Name属性用作调试用途。这个属性在Visual Studio中尤其有用，因为线程的名称会显示在“Thread”窗口和“Debug Location”工具栏上。线程的名称只能够设置一次，试图修改线程的名
C# 开启线程的四种方式
最新发布
2401_82584055的博客
06-04 470
以上四种方式各有优缺点，适用于不同的场景。Thread类提供了对线程的底层控制，但使用起来相对繁琐；Task类和方法提供了更高级的抽象和更好的性能；而asyncawait则进一步简化了异步编程模型，使得代码更易读和维护。在实际开发中，应根据具体需求选择合适的方式。
C#多线程编程技术——多线程操作（没看懂）
DXB2021的博客
07-13 3165
多线程操作
C#多线程入门概念及技巧
Z_hongli的博客
11-11 630
线程是操作系统中能够独立运行的最小单位，也是程序中能够并发执行的一段指令序列线程是进程的一部分，一个进程可以包括多个线程，这个线程可以共享进程的资源进程有入口线程，也可用创建更多的线程。
c#中使用线程的方式
zxf347085420的博客
07-08 349
1、使用Thread //将函数DoWork()，放入一个新线程中，并开启这个线程 Thread thread = new Thread(() => this.DoWork()); //或者 Thread thread = new Thread(new ThreadStart(DoWork)); thread.Start(); 2、使用Task 2.1 方式1 Task...
C#队列Queue多线程用法实例
09-03
在C#编程中，队列（Queue）是一种线性数据结构，它遵循“先进先出”（First In First Out, FIFO）的原则。队列在多线程环境下常常用于任务...理解这些基本概念和操作对于开发涉及多线程和队列的C#应用程序至关重要。
贪吃蛇程序设计-详细-C#-窗体
12-12
在C#中实现这个游戏，将涉及到图形界面设计、事件处理、多线程以及游戏逻辑等多个方面的知识。 首先，我们要创建一个Windows窗体应用程序项目。在Visual Studio中，选择"新建项目"，然后在模板中找到"C# -> Windows...
C#实现进度条显示 - 多线程
10-12
在C#编程中，创建一个进度条来展示应用程序执行任务的进度是十分常见的需求，特别是在进行耗时操作时，为了提升用户体验，用户界面需要能够反映出后台处理的状态。本示例介绍如何利用C#的Windows Forms和`...
C#中的线程(三)使用多线程
12-09
单元模式和Windows Forms BackgroundWorker类 ReaderWriterLock类 线程池 异步委托 计时器 局部储存
C#多线程之（Thread）详解与示例
qq_35320456的博客
04-24 3546
C# 多线程编程是提高应用程序性能和响应性的有效方式。通过 Thread 类，您可以创建和启动新的线程，管理线程的生命周期，以及实现线程之间的通信。然而，多线程编程也带来了线程安全的问题，需要通过锁、线程局部变量、Concurrent collections 和 Task 等方式来确保数据的一致性和程序的稳定性。执行耗时的计算或IO操作，如文件处理、数据加密、图像处理等。处理用户界面任务，如后台处理、异步更新UI组件等。实现并行算法，提高计算效率，如矩阵计算、科学模拟等。
C#多线程编程详细教学
laizhixue的博客
03-29 1404
然而，多线程编程也带来了线程安全和同步的问题，需要使用适当的同步机制来确保数据的一致性和避免线程冲突。在编写多线程程序时，应该仔细考虑线程间的交互和共享资源的访问方式，以确保程序的正确性和性能。在C#中，多线程编程是一种非常重要的技术，它允许程序同时执行多个任务，从而提高了应用程序的响应性和整体性能。一个线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。有时候，简单的lock或Monitor就能满足需求，而在复杂的场景下，可能需要结合多种策略来确保线程安全。
【C#】线程操作总结
liudongdong_jlu
12-26 4468
1. 线程基础 .1. 生命周期 在线程的生命周期中，它要经过新建（New）、就绪（Runnable）、行（Running）、阻塞（Blocked）和死亡（Dead）五种状态。当线程start后，它不能一直"独占"着CPU独自运行，所以CPU需要在多条线程之间切换，于是线程状态也会多次在运行、阻塞之间切换. 新建状态（new）：指新建了一个线程对象。Thread t1 =new Thread();这里就新建了一个Thread类的线程对象。 就绪状态（Runnable）：当线程对象创建后，该线程对.
如何让asp.net执行命令，暂停几秒，再执行下一行命令?(已解决)
【敦厚的曹操】的专栏
12-11 1万+
如何让asp.net执行命令，暂停几秒，再执行下一行命令?(已解决) Thread.Sleep(1000);  // 1000为一秒 或者用 System.Threading.Thread.Sleep(1000);    //1秒
C#中这样用Sleep()...
热门推荐
friendan的专栏
03-13 5万+
//呵呵，两行代码就可以了... using System.Threading; //导入命名空间,类Thread就在此空间中   Thread.Sleep(10000);
C#两种进程暂停和继续的方法 2021-02-16
weixin_43727933的博客
02-16 5744
C#两种进程暂停和继续的方法方法一方法二 方法一 可以使用Thread.Suspend和Thread.Resume而这两个方法。 namespace ThreadSuspended { public partial class Form1 : Form { public Form1() { InitializeComponent(); }
C#多线程实战：获取CPU信息及注册表操作
线程是操作系统调度的基本单位，它允许在单个进程中同时执行多个任务，从而实现并发性。在Windows系统中，进程可以包含多个线程，每个线程都有自己的执行路径。多线程的优点包括提高程序响应速度、优化资源使用和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值