【C#补全计划】多线程

柠檬味的薄荷心2025-08-18 15:58

一、进程

  1. 概念：进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础

  2. 进程之间可以相互独立运行、互不干扰，也可以相互访问、操作

二、线程

  1. 概念：操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位

  2. 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程

三、多线程的语法

  1. 类：Thread

  2. 引用命名空间：using System.Threading;

  3. 声明一个新线程：Thread 线程名 = new Thread();

cs 复制代码 
using System;
using System.Threading;

namespace Multithreading
{
    class Program
    {
        static void Main(string[] args)
        {
            // 声明一个新线程
            // 注意：线程执行的代码需要封装到一个新函数中
            Thread t1 = new Thread(threadMethod1);
        }

        static void threadMethod1()
        {
            Console.WriteLine("线程1的逻辑...");
        }
    }
}
  1. 启动线程：线程名.Start();
cs 复制代码 
using System;
using System.Threading;

namespace Multithreading
{
    class Program
    {
        static void Main(string[] args)
        {
            // 声明一个新线程
            // 注意：线程执行的代码需要封装到一个新函数中
            Thread t1 = new Thread(threadMethod1);
            
            // 启动线程
            t1.Start();
        }

        static void threadMethod1()
        {
            Console.WriteLine("运行线程1的逻辑...");
        }
    }
}
  1. 设置为后台线程：线程名.IsBackground = true;

（1）当所有前台线程结束的时候，整个程序就结束了。无论是否还有后台线程在运行。

（2）后台线程会随着应用程序进程的终止而终止

（3）如果不设置为后台线程，可能导致进程无法正常关闭

（4）若线程1无限循环：

cs 复制代码 
using System;
using System.Threading;

namespace Multithreading
{
    class Program
    {
        static void Main(string[] args)
        {
            // 声明一个新线程
            // 注意：线程执行的代码需要封装到一个新函数中
            Thread t1 = new Thread(threadMethod1);
            
            // 启动线程
            t1.Start();
        }

        static void threadMethod1()
        {
            while (true) {
                Console.WriteLine("运行线程1的逻辑...");
            }
        }
    }
}

运行结果如下：（无限循环执行）

（5）设置线程1为后台线程：

cs 复制代码 
using System;
using System.Threading;

namespace Multithreading
{
    class Program
    {
        static void Main(string[] args)
        {
            // 声明一个新线程
            // 注意：线程执行的代码需要封装到一个新函数中
            Thread t1 = new Thread(threadMethod1);
            
            // 启动线程
            t1.Start();
            
            // 设置为后台线程
            t1.IsBackground = true;

            for (int i = 0; i < 10; ++i) {
                Console.WriteLine("运行主线程的逻辑...");
            }
        }

        static void threadMethod1()
        {
            while (true) {
                Console.WriteLine("运行线程1的逻辑...");
            }
        }
    }
}

运行结果如下：（主线程结束后线程1也结束）

  1. 释放线程：

（1）如果开启的线程不是死循环，不需要刻意去关闭

（2）如果开启的线程是死循环，有两种关闭方式：

①设置bool标识

cs 复制代码 
using System;
using System.Threading;

namespace Multithreading
{
    class Program
    {
        static bool isRuning = true;
        
        static void Main(string[] args)
        {
            // 声明一个新线程
            // 注意：线程执行的代码需要封装到一个新函数中
            Thread t1 = new Thread(threadMethod1);
            
            // 启动线程
            t1.Start();
            
            // 设置为后台线程
            t1.IsBackground = true;
            
            for (int i = 0; i < 10; ++i) {
                Console.WriteLine("运行主线程的逻辑...");
            }
            
            // 释放线程
            // 1.设置bool标识
            isRuning = false;
        }

        static void threadMethod1()
        {
            while (isRuning) {
                Console.WriteLine("运行线程1的逻辑...");
            }
        }
    }
}

运行结果如下：

②调用线程提供的Abort方法

cs 复制代码 
using System;
using System.Threading;

namespace Multithreading
{
    class Program
    {
        // static bool isRuning = true;
        
        static void Main(string[] args)
        {
            // 声明一个新线程
            // 注意：线程执行的代码需要封装到一个新函数中
            Thread t1 = new Thread(threadMethod1);
            
            // 启动线程
            t1.Start();
            
            // 设置为后台线程
            t1.IsBackground = true;
            
            for (int i = 0; i < 10; ++i) {
                Console.WriteLine("运行主线程的逻辑...");
            }
            
            // 释放线程
            // 1.设置bool标识
            // isRuning = false;
            
            // 2.使用线程的Abort方法
            t1.Abort();
        }

        static void threadMethod1()
        {
            while (true) {
                Console.WriteLine("运行线程1的逻辑...");
            }
        }
    }
}

运行结果同上。

注意：在.Net core版本中无法中止，会发生报错

  1. 休眠线程：Thread.Sleep();
cs 复制代码 
using System;
using System.Threading;

namespace Multithreading
{
    class Program
    {
        // static bool isRuning = true;
        
        static void Main(string[] args)
        {
            // 声明一个新线程
            // 注意：线程执行的代码需要封装到一个新函数中
            Thread t1 = new Thread(threadMethod1);
            
            // 启动线程
            t1.Start();
            
            // 设置为后台线程
            t1.IsBackground = true;
            
            for (int i = 0; i < 10; ++i) {
                Console.WriteLine("运行主线程的逻辑...");
            }
            
            // 释放线程
            // 1.设置bool标识
            // isRuning = false;
            
            // 2.使用线程的Abort方法
            t1.Abort();
            
            // 休眠线程
            // 在哪个函数中调用，就使哪个线程休眠
            Thread.Sleep(1000); // 使线程休眠1000毫秒 1秒=1000毫秒
        }

        static void threadMethod1()
        {
            while (true) {
                Console.WriteLine("运行线程1的逻辑...");
            }
        }
    }
}

四、线程之间共享数据

  1. 多个线程之间使用的内存使共享的，都属于应用程序（进程）

  2. 要注意：当多线程同时操作同一片内存区域时可能会出问题，但是可以通过加锁的形式避免

  3. 关键字：lock

  4. 作用：在多个线程想要访问相同的内存时，实现共享资源的安全访问

  5. 语法：

lock(引用类型对象){

// 代码块

}

  1. 实现：在(0,0)处绘制一个红色的圆形、在(10,5)处绘制一个黄色的正方形

代码：

cs 复制代码 
using System;
using System.Threading;

namespace Multithreading
{
    class Program
    {
        // static bool isRuning = true;
        
        static void Main(string[] args)
        {
            // 声明一个新线程
            // 注意：线程执行的代码需要封装到一个新函数中
            Thread t1 = new Thread(threadDrawCir);
            Thread t2 = new Thread(threadDrawRec);
            
            // 启动线程
            t1.Start();
            t2.Start();
            
            // 设置为后台线程
            t1.IsBackground = true;
            t2.IsBackground = true;
            
            // 释放线程
            // 1.设置bool标识
            // isRuning = false;
            
            // 2.使用线程的Abort方法
            // t1.Abort();
            
            // 休眠线程
            // 在哪个函数中调用，就使哪个线程休眠
            // Thread.Sleep(1000); // 使线程休眠1000毫秒 1秒=1000毫秒
            
            // 等待按键后结束前台进程
            Console.ReadKey();
        }

        static void threadDrawCir() // 在(0,0)处绘制一个红色的圆形
        {
            while (true) { 
                Console.SetCursorPosition(0, 0);
                Console.ForegroundColor = ConsoleColor.Red;
                Console.Write("●");
            }
        }

        static void threadDrawRec() // 在(10,5)处绘制一个黄色的正方形
        {
            while (true) {
                Console.SetCursorPosition(10, 5);
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.Write("■");
            }
        }
    } 
}

运行结果如下;

出现该结果的原因是：因为两个线程是同时运行的，所以当在(0,0)处绘制一个红色的圆形后，没有将光标设置为(10,5)，直接从绘制黄色的正方形开始运行。同理，在(10,5)处绘制一个黄色的正方形后，没有将光标设置为(0,0)，直接从绘制红色的圆形开始运行。所以会出现上面的效果。

  1. 使用互斥锁：
cs 复制代码 
using System;
using System.Threading;

namespace Multithreading
{
    class Program
    {
        // static bool isRuning = true;
        static object lockObj = new object(); // 创建一个互斥锁对象
        
        static void Main(string[] args)
        {
            // 声明一个新线程
            // 注意：线程执行的代码需要封装到一个新函数中
            Thread t1 = new Thread(threadDrawCir);
            Thread t2 = new Thread(threadDrawRec);
            
            // 启动线程
            t1.Start();
            t2.Start();
            
            // 设置为后台线程
            t1.IsBackground = true;
            t2.IsBackground = true;
            
            // 释放线程
            // 1.设置bool标识
            // isRuning = false;
            
            // 2.使用线程的Abort方法
            // t1.Abort();
            
            // 休眠线程
            // 在哪个函数中调用，就使哪个线程休眠
            // Thread.Sleep(1000); // 使线程休眠1000毫秒 1秒=1000毫秒
            
            // 等待按键后结束前台进程
            Console.ReadKey();
        }

        static void threadDrawCir() // 在(0,0)处绘制一个红色的圆形
        {
            while (true) {
                lock (lockObj) { // 使用互斥锁
                    Console.SetCursorPosition(0, 0);
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.Write("●");
                }
            }
        }

        static void threadDrawRec() // 在(10,5)处绘制一个黄色的正方形
        {
            while (true) {
                lock (lockObj) { // 使用互斥锁
                    Console.SetCursorPosition(10, 5);
                    Console.ForegroundColor = ConsoleColor.Yellow;
                    Console.Write("■");
                }
            }
        }
    } 
}

运行结果如下;

  1. 解释：访问lock中的代码块，会给该引用类型对象上锁；直到运行完所有lock代码块中的代码时，该引用类型对象才会解锁。在其他线程想要使用该引用对象时，若该对象已经上锁，则必须等待该对象解锁后才能继续运行。

五、多线程的意义

使用多线程专门处理一些复杂耗时的逻辑：比如寻路、网络通信等

今天的学习就到这里了。感谢阅读。

再见！

相关推荐
linweidong2 小时前
理想汽车Java后台开发面试题及参考答案(下）
jvm·spring boot·spring cloud·rpc·虚拟机·feign·二叉树排序
大大大大物~2 小时前
JVM之锁优化(自旋锁 适应性自旋 锁消除 锁粗化 轻量级锁 偏向锁)
jvm
无毁的湖光Al6 小时前
日常问题排查-Younggc突然变长
java·jvm·后端
..Cherry..7 小时前
【java】jvm
java·开发语言·jvm
zz-zjx21 小时前
JVM 内存结构与 GC 机制详解（ 实战优化版）
java·jvm·tomcat
siriuuus1 天前
JVM 内存分区及 GC 垃圾回收 相关知识总结
jvm·full gc
Arlene1 天前
JVM Java虚拟机
java·开发语言·jvm
老K的Java兵器库1 天前
对象创建源码追踪：从 new 指令到 JVM 内部实现
java·jvm
老K的Java兵器库1 天前
Metaspace OOM 排查实录：一次 Spring 热部署爆掉 256 M 元空间
java·jvm·spring
syt_biancheng1 天前
C++ 多态（1）
jvm·c++·学习
热门推荐
01BongoCat - 跨平台键盘猫动画工具02GitHub 镜像站点03UV安装并设置国内源04Linux下V2Ray安装配置指南05两千字总结：Codex 国内如何安装和使用的教程，以及如何设置中文回答06KGG转MP3工具|非KGM文件|解密音频07GitLab 零基础入门指南：从安装到项目管理全流程08荣耀手机2025年10月发布的新品Magic8比起Magic7，在硬件、性能、价格等上有什么区别，有什么优势09windows找不到gpedit.msc（本地组策略编辑器）10NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南