黑马程序员线程

最新推荐文章于 2025-05-18 20:51:20 发布

原创最新推荐文章于 2025-05-18 20:51:20 发布 · 384 阅读

0 ·

CC 4.0 BY-SA版权

本文介绍了线程的基础概念及.NET中的多线程应用。详细解释了线程的创建、控制方法如启动、挂起、恢复及终止等，并讨论了线程的优先级设置。此外，还探讨了多线程的优势与潜在问题，包括资源竞争问题及其解决方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

------- Windows Phone 7手机开发、.Net培训、期待与您交流！ -------

一个进程是由多个线程组成，线程是执行进程的基本单位。

在运用线程之前，要把System.Threading命名空间包含进来。

线程的常用属性：

IsAlive：判断线程是否处于活动状态。

Name：线程的名字。

Priority：ThreadPriority枚举类型，代表线程的优先级。

IsBackground：后台线程，设置为true则为后台，默认为前台线程

ThreadState：ThreadState枚举类型，代表线程的状态。

Start：启动一个线程。

Suspend：挂起一个线程。

Resume：继续挂起的线程。

Abort：结束一个线程。

关于线程的优先级：

Normal：普通级别。

AboveNormal：高于普通级别。

BelowNormal：低于普通级别。

Highest：最高级别。

Lowest：最低级别。

例：ThreadSimple.Priority = ThreadPriority.Highest;

创建一个线程：

Thread oThread = new Thread(线程要执行的方法名);//创建一个线程。

oThread.Start();//启动一个线程。

关于线程的休眠：休眠线程是让进程进入一定时间的休眠状态，时间一到，线程将继续运行。

oThread.sleep(10000);//休眠10秒。

关于线程的挂起：挂起跟休眠不同，线程的挂起是暂停线程，如果不再启动线程，它将永远的保持暂停状态。只有当前运行的线程才能挂起。

oThread.Suspend();//挂起一个线程

oThread.Resume();//继续被挂起的线程

一个应用程序就是一个线程，在启动应用程序的时候，再启动其他相对比较复杂或者耗费时间的算法，由于只有一个线程就会出现界面卡住的状况。所以我们运用到多线程。

多线程的好处：

计算机“同时”做很多事情，节约时间。
后台运行程序，提高程序的运行效率，也不会使界面出现无响应的状态。
多线程让程序同时处理不同的事件。
计算机CPU大部分时间处于空闲状态，多线程能很好利用CPU的资源。

多线程也有不好的地方：

线程也是程序，所以线程需要占用内存，线程越多占用内存也越多；
多线程需要协调和管理，所以需要CPU时间跟踪线程；
线程之间对共享资源的访问会相互影响，必须解决竞用共享资源的问题；
线程太多会导致控制太复杂，最终可能造成很多Bug；

当线程间需要共享数据的时候，要把该数据设定为静态的，试用关键字“static”。

在多线程同时再对同一个东西执行操作的时候，如果不加以控制，就会出现一个线程执行一半的时候，另外的线程又把这个数据提取出来执行，将会出现很大的随意性，和不可控制性。这时可以用lock或者mutex或者monitor来控制约束

例：加了Lock锁的代码与结果

static void MethobSub1()
        {
            do
            {
                lock (lockExample)//对线程内进行锁定
                {
                    i = i + 1;
                    Console.WriteLine("线程1开始，i={0}", i);
                    Thread.Sleep(2000);
                    Console.WriteLine("线程1结束，i={0}", i);
                }
            } while (1 == 1);
        }
        static void MethobSub2()
        {
            do
            {
                lock (lockExample)
                {
                    i = i - 1;
                    Console.WriteLine("线程2开始，i={0}", i);
                    Thread.Sleep(2000);
                    Console.WriteLine("线程2结束，i={0}", i);
                }
            } while (1 == 1);
        }
        public static object lockExample = new object();
        static int i = 100;
        static void Main(string[] args)
        {
            Thread oThreads1 = new Thread(new ThreadStart(MethobSub1));
            Thread oThreads2 = new Thread(new ThreadStart(MethobSub2));
            oThreads1.Start();
            oThreads2.Start();
            do
            {
                if (Console.Read() == 'e')//按e并回车，退出子线程，退出循环。
                {
                    oThreads1.Abort();
                    oThreads1.Abort();
                    break;
                }
            } while (1 == 1);
        }

结果：

未加锁的代码：

static void MethobSub1()
        {
            do
            {
                i = i + 1;
                Console.WriteLine("线程1开始，i={0}", i);
                Thread.Sleep(1000);
                Console.WriteLine("线程1结束，i={0}", i);
            } while (1 == 1);
        }
        static void MethobSub2()
        {
            do
            {
                i = i - 1;
                Console.WriteLine("线程2开始，i={0}", i);
                Thread.Sleep(1000);
                Console.WriteLine("线程2结束，i={0}", i);
            } while (1 == 1);
        }
        static int i = 100;
        static void Main(string[] args)
        {
            Thread oThreads1 = new Thread(new ThreadStart(MethobSub1));
            Thread oThreads2 = new Thread(new ThreadStart(MethobSub2));
            oThreads1.Start();
            oThreads2.Start();
            do
            {
                if (Console.Read() == 'e')//按e并回车，退出子线程，退出循环。
                {
                    oThreads1.Abort();
                    oThreads1.Abort();
                    break;
                }
            } while (1 == 1);
        }

结果：