Ｃ＃多线程编程

最新推荐文章于 2025-06-01 08:21:09 发布
转载 最新推荐文章于 2025-06-01 08:21:09 发布 · 652 阅读 · 2
文章标签：

#多线程 #编程 #object #thread #download #locking

//一个简单的示例
//HelloWordThread.cs//------------------------using System;
using System.Threading;

public class Test
{
    static void Main()
    {
        ThreadStart job = new ThreadStart(ThreadJob);
        Thread thread = new Thread(job);
        thread.Start();
        
        for (int i=0; i < 5; i++)
        {
            Console.WriteLine ("Main thread: {0}", i);
            Thread.Sleep(1000);
        }
    }
    
    static void ThreadJob()
    {
        for (int i=0; i < 10; i++)
        {
            Console.WriteLine ("Other thread: {0}", i);
            Thread.Sleep(500);
        }
    }
}结果：
Main thread: 0
Other thread: 0
Other thread: 1
Main thread: 1
Other thread: 2
Other thread: 3
Main thread: 2
Other thread: 4
Other thread: 5
Main thread: 3
Other thread: 6
Other thread: 7
Main thread: 4
Other thread: 8
Other thread: 9 
//UsingDelegate.cs
------------------------------------
using System;
using System.Threading;

public class Test
{
    static void Main()
    {
        Counter foo = new Counter();
        ThreadStart job = new ThreadStart(foo.Count);
        Thread thread = new Thread(job);
        thread.Start();
        
        for (int i=0; i < 5; i++)
        {
            Console.WriteLine ("Main thread: {0}", i);
            Thread.Sleep(1000);
        }
    }
}

public class Counter
{
    public void Count()
    {
        for (int i=0; i < 10; i++) { Console.WriteLine ("Other thread: {0}", i);
            Thread.Sleep(500);
        }
    }
}

二、线程中的参数传递
使用类、类的方法或类的属性都可以向线程传递参数：
public class UrlDownloader
{ string url; public UrlDownloader (string url) { this.url = url; } public void Download() {
WebClient wc = new WebClient();
Console.WriteLine("Downloading " + url); byte[] buffer = wc.DownloadData (url); string download = Encoding.ASCII.GetString(buffer); Console.WriteLine(download); Console.WriteLine("Download successful.");
//这里你可以将download进行保存等处理...... } } [... 在另一个类中使用它们...] UrlDownloader downloader = new UrlDownloader (yourUrl); new Thread (new ThreadStart (downloader.Download)).Start(); 
注意参数是如何传递的。
在.NET 2.0中还可以这样：
(CODE-BESIDE）
方式一：
ThreadStart starter = delegate { Download(yourUrl); });
new Thread(starter).Start();
//使用线程池

WaitCallback callback = delegate (object state) { Download ((string)state); };
ThreadPool.QueueUserWorkItem (callback, yourUrl);



方式二(使用ParameterizedThreadStart)：


Thread t = new Thread (new ParameterizedThreadStart(DownloadUrl));
t.Start (myUrl);

static void DownloadUrl(object url)
{
    // ....
}

 三、线程内部是如何进行的？

看一下以下两个例子的运行结果：
//TestThread.csusing System;
using System.Threading;

public class Test
{
    static int count=0;
    
    static void Main()
    {
        ThreadStart job = new ThreadStart(ThreadJob);
        Thread thread = new Thread(job);
        thread.Start();
        
        for (int i=0; i < 5; i++)
        {
            count++;
        }
        
        thread.Join();
        Console.WriteLine ("Final count: {0}", count);
    }
    
    static void ThreadJob()
    {
        for (int i=0; i < 5; i++)
        {
            count++;
        }
    }
} 
   

//InnerDataThread.csusing System;
using System.Threading;

public class Test
{
    static int count=0;
    
    static void Main()
    {
        ThreadStart job = new ThreadStart(ThreadJob);
        Thread thread = new Thread(job);
        thread.Start();
        
        for (int i=0; i < 5; i++)
        {
            int tmp = count;
            Console.WriteLine ("Read count={0}", tmp);
            Thread.Sleep(50);
            tmp++;
            Console.WriteLine ("Incremented tmp to {0}", tmp);
            Thread.Sleep(20);
            count = tmp;
            Console.WriteLine ("Written count={0}", tmp);
            Thread.Sleep(30);
        }
        
        thread.Join();
        Console.WriteLine ("Final count: {0}", count);
    }
    
    static void ThreadJob()
    {
        for (int i=0; i < 5; i++)
        {
            int tmp = count;
            Console.WriteLine (" Read count={0}", tmp);
            Thread.Sleep(20);
            tmp++;
            Console.WriteLine (" Incremented tmp to {0}", tmp);
            Thread.Sleep(10);
            count = tmp;
            Console.WriteLine (" Written count={0}", tmp);
            Thread.Sleep(40);
        }
    }
}
Read count=0
                                Read count=0
                                Incremented tmp to 1
                                Written count=1
Incremented tmp to 1
Written count=1
                                Read count=1
                                Incremented tmp to 2
Read count=1
                                Written count=2
                                Read count=2
Incremented tmp to 2
                                Incremented tmp to 3
Written count=2
                                Written count=3
Read count=3
                                Read count=3
Incremented tmp to 4
                                Incremented tmp to 4
                                Written count=4
Written count=4
                                Read count=4
Read count=4
                                Incremented tmp to 5
                                Written count=5
Incremented tmp to 5
Written count=5
Read count=5
Incremented tmp to 6
Written count=6
Final count: 6

再比较下面这个例子：

 

//使用Monitor.Enter/Exit 
//MonitorThread.cs

using System;
using System.Threading;

public class Test
{
    static int count=0;
    static readonly object countLock = new object();
    
    static void Main()
    {
        ThreadStart job = new ThreadStart(ThreadJob);
        Thread thread = new Thread(job);
        thread.Start();
        
        for (int i=0; i < 5; i++)
        {
            Monitor.Enter(countLock);
            int tmp = count;
            Console.WriteLine ("Read count={0}", tmp);
            Thread.Sleep(50);
            tmp++;
            Console.WriteLine ("Incremented tmp to {0}", tmp);
            Thread.Sleep(20);
            count = tmp;
            Console.WriteLine ("Written count={0}", tmp);
            Monitor.Exit(countLock);
            Thread.Sleep(30);
        }
        
        thread.Join();
        Console.WriteLine ("Final count: {0}", count);
    }
    
    static void ThreadJob()
    {
        for (int i=0; i < 5; i++)
        {
            Monitor.Enter(countLock);
            int tmp = count;
            Console.WriteLine (" Read count={0}", tmp);
            Thread.Sleep(20);
            tmp++;
            Console.WriteLine (" Incremented tmp to {0}", tmp);
            Thread.Sleep(10);
            count = tmp;
            Console.WriteLine (" Written count={0}", tmp);
            Monitor.Exit(countLock);
            Thread.Sleep(40);
        }
    }
}


结果与上例InnerDataThread.cs是不一样的，原因就在于Monitor的使用了。

Read count=0
Incremented tmp to 1
Written count=1
                                Read count=1
                                Incremented tmp to 2
                                Written count=2
Read count=2
Incremented tmp to 3
Written count=3
                                Read count=3
                                Incremented tmp to 4
                                Written count=4
Read count=4
Incremented tmp to 5
Written count=5
                                Read count=5
                                Incremented tmp to 6
                                Written count=6
Read count=6
Incremented tmp to 7
Written count=7
                                Read count=7
                                Incremented tmp to 8
                                Written count=8
Read count=8
Incremented tmp to 9
Written count=9
                                Read count=9
                                Incremented tmp to 10
                                Written count=10
Final count: 10

下面使用lock来锁定线程：

// LockThread.cs
using System;
using System.Threading;

public class Test
{
    static int count=0;
    static readonly object countLock = new object();
    
    static void Main()
    {
        ThreadStart job = new ThreadStart(ThreadJob);
        Thread thread = new Thread(job);
        thread.Start();
        
        for (int i=0; i < 5; i++)
        {
            lock (countLock)
            {
                int tmp = count;
                Console.WriteLine ("Read count={0}", tmp);
                Thread.Sleep(50);
                tmp++;
                Console.WriteLine ("Incremented tmp to {0}", tmp);
                Thread.Sleep(20);
                count = tmp;
                Console.WriteLine ("Written count={0}", tmp);
            }
            Thread.Sleep(30);
        }
        
        thread.Join();
        Console.WriteLine ("Final count: {0}", count);
    }
    
    static void ThreadJob()
    {
        for (int i=0; i < 5; i++)
        {
            lock (countLock)
            {
                int tmp = count;
                Console.WriteLine (" Read count={0}", tmp);
                Thread.Sleep(20);
                tmp++;
                Console.WriteLine (" Incremented tmp to {0}", tmp);
                if (count < 100)
                    throw new Exception();
                Thread.Sleep(10);
                count = tmp;
                Console.WriteLine (" Written count={0}", tmp);
            }
            Thread.Sleep(40);
        }
    }
}


结果如何？与MonitorThread.cs比较一下，再想想看。

四、死锁

// DeadLockSample.cs
// 分析一下为什么会发生死锁？

 

using System;
using System.Threading;

public class Test
{
    static readonly object firstLock = new object();
    static readonly object secondLock = new object();
    
    static void Main()
    {
        new Thread(new ThreadStart(ThreadJob)).Start();
        
        // Wait until we're fairly sure the other thread
        // has grabbed firstLock
        Thread.Sleep(500);
        
        Console.WriteLine ("Locking secondLock");
        lock (secondLock)
        {
            Console.WriteLine ("Locked secondLock");
            Console.WriteLine ("Locking firstLock");
            lock (firstLock)
            {
                Console.WriteLine ("Locked firstLock");
            }
            Console.WriteLine ("Released firstLock");
        }
        Console.WriteLine("Released secondLock");
    }
    
    static void ThreadJob()
    {
        Console.WriteLine (" Locking firstLock");
        lock (firstLock)
        {
            Console.WriteLine(" Locked firstLock");
            // Wait until we're fairly sure the first thread
            // has grabbed secondLock
            Thread.Sleep(1000);
            Console.WriteLine(" Locking secondLock");
            lock (secondLock)
            {
                Console.WriteLine(" Locked secondLock");
            }
            Console.WriteLine (" Released secondLock");
        }
        Console.WriteLine(" Released firstLock");
    }
}

 

Locking firstLock
Locked firstLock 
Locking secondLock 
Locked secondLock 
Locking firstLock Locking secondLock

因应之道，使用Queue和Monitor:

 

//QueueMonitorThread.cs

using System;
using System.Collections;
using System.Threading;

public class Test
{
    static ProducerConsumer queue;
    
    static void Main()
    {
        queue = new ProducerConsumer();
        new Thread(new ThreadStart(ConsumerJob)).Start();
        
        Random rng = new Random(0);
        for (int i=0; i < 10; i++)
        {
            Console.WriteLine ("Producing {0}", i);
            queue.Produce(i);
            Thread.Sleep(rng.Next(1000));
        }
    }
    
    static void ConsumerJob()
    {
        // Make sure we get a different random seed from the
        // first thread
        Random rng = new Random(1);
        // We happen to know we've only got 10 
        // items to receive
        for (int i=0; i < 10; i++)
        {
            object o = queue.Consume();
            Console.WriteLine (" Consuming {0}", o);
            Thread.Sleep(rng.Next(1000));
        }
    }
}

public class ProducerConsumer
{
    readonly object listLock = new object();
    Queue queue = new Queue();

    public void Produce(object o)
    {
        lock (listLock)
        {
            queue.Enqueue(o);
            if (queue.Count==1)
            {
                Monitor.Pulse(listLock);
            }
        }
    }
    
    public object Consume()
    {
        lock (listLock)
        {
            while (queue.Count==0)
            {
                Monitor.Wait(listLock);
            }
            return queue.Dequeue();
        }
    }
}

 

Producing 0 Consuming 0
Producing 1 Consuming 1
Producing 2 Consuming 2
Producing 3 Consuming 3
Producing 4
Producing 5 Consuming 4
Producing 6 Consuming 5
                                         Consuming 6
Producing 7 Consuming 7
Producing 8 Consuming 8
Producing 9 Consuming 9
C# 多线程编程
片言可决讼，半纸能缚龙
11-11 1234
CSharp 多线程的使用
C# 多线程编程：线程锁与无锁并发
吾家有猫名探花的博客
03-28 3851
多线程编程在现代软件开发中至关重要。本文将讨论 C# 中的多线程技术，重点介绍锁的概念，线程锁与无锁并发。通过学习本篇博文，我们将学会如何正确处理并发问题，提高程序的性能和稳定性。锁是一种同步机制，用于控制多个线程对共享资源的访问。当一个线程获得了锁时，其他线程将被阻塞，直到该线程释放了锁。本文深入探讨了 C# 中的多线程编程技术，重点介绍了锁的基本概念、线程锁的类型、锁的实现方式、无锁并发编程以及 C# 中的并发集合类和经典并发同步问题。理解多线程编程的基本概念。
C#多线程编程
weixin_42647208的博客
02-04 3016
目录1. 多线程描述2. 线程生命周期3. 线程的常用属性与方法4. 线程操作(1) 创建线程(2) 管理线程(3) 销毁线程 1. 多线程描述 线程 被定义为程序的执行路径。每个线程都定义了一个独特的控制流。在多线程之下可以通过分配线程，同时处理多个任务。 2. 线程生命周期 线程生命周期开始于 System.Threading.Thread 类的对象被创建时，结束于线程被终止或完成执行时。 下面列出了线程生命周期中的各种状态： 未启动状态：当线程实例被创建但 Start 方法未被调用时的状况。 就绪状
C#多线程编程实战指南
weixin_34620658的博客
11-10 913
本文还有配套的精品资源，点击获取 简介：本教程以多线程编程在C#中的实际应用为核心，为初学者提供了一个理解并实践多线程的起点。介绍了C#中线程的基本概念、Thread类的使用、ThreadPool的线程池机制、Task Parallel Library (TPL)的高级并行编程能力以及async/await异步编程模式。同时，讲解了多线程编程中常见的同步问题和解决工具，例如...
C#多线程编程详细教学
laizhixue的博客
03-29 2001
然而，多线程编程也带来了线程安全和同步的问题，需要使用适当的同步机制来确保数据的一致性和避免线程冲突。在编写多线程程序时，应该仔细考虑线程间的交互和共享资源的访问方式，以确保程序的正确性和性能。在C#中，多线程编程是一种非常重要的技术，它允许程序同时执行多个任务，从而提高了应用程序的响应性和整体性能。一个线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。有时候，简单的lock或Monitor就能满足需求，而在复杂的场景下，可能需要结合多种策略来确保线程安全。
C# 多线程编程全面指南：从基础到高级实践
vvilkin的学习备忘
06-01 1131
在现代软件开发中，多线程编程已成为提升应用程序性能的关键技术。C# 作为.NET平台的主力语言，提供了丰富的多线程处理机制。本文将全面介绍C#中的多线程编程技术，从基础概念到高级应用，帮助开发者掌握这一重要技能。
C# 多线程编程完全指南：从基础到高级应用
net core ，前端 ，python 全栈开发
03-07 1405
多线程编程是现代开发中不可或缺的一部分，它可以显著提高程序的执行效率和响应能力。C# 提供了多种线程管理和同步机制，如Thread类、lockMonitor和Mutex，它们能够帮助开发者应对多线程编程中的常见问题，如数据竞争和死锁。通过合理使用线程池和异步编程模型，开发者可以更高效地处理并发任务，提高程序的性能和稳定性。在实际应用中，合理选择同步机制、合理设计线程管理策略、避免死锁和竞态条件，是编写高效、稳定的多线程程序的关键。
C#多线程编程详细教学_c# 创建线程
2401_84968643的博客
05-16 746
在上面的例子中，lockObject是一个私有的对象，用作同步锁。Monitor 类：Monitor类提供了与lock关键字相同的功能，但它是通过方法调用的形式来实现的。注意，在C# 7.1及更高版本中，Main方法可以被声明为async，这使得我们可以方便地在主线程中使用await关键字来等待异步操作。在上面的示例中，我们使用lock关键字来确保在增加sharedCounter时只有一个线程能够访问它。需要注意的是，过度使用线程同步可能会导致性能下降，因此应该谨慎使用，并只在必要时进行同步。
全面掌握C#多线程编程：核心机制、高级技巧与性能调优
Rocn666的博客
03-10 1453
​操作系统线程调度机制​内存模型与原子操作​异步编程的编译器魔法​性能优化与诊断工具避免常见陷阱（如死锁、伪共享）并合理选择同步原语（锁、信号量、无锁结构），才能编写高效且健壮的并发代码。（Java可参考）
C#多线程编程-必知必会
dotNET跨平台
09-23 572
“发现问题的能力，运用技术解决问题的能力，是一个技术人成长的关键”@图片故事：洋姜的花，拍摄于2022年7月23日，地点：北京奥林匹克森林公园 ，摄影师：刘先生概要：使用C#发起多线程任务十分简单，本文旨在汇总多线程编程的注意事项，重点不在于如何发起多线程，主要内容如下：控制线程并发数量界定共享资源加锁并控制锁范围子线程异常处理未完成任务取消希望对小伙伴儿们有所帮助01—控制线程并发数量多线程以多...
C#多线程编程实例实战.pdf
10-24
C#多线程编程实例实战 C#多线程编程实例实战是指在C#语言中实现多线程编程的实例和实战经验。多线程编程是指在同一个进程中创建多个线程，以便提高程序的执行效率和响应速度。在C#语言中，可以使用Thread类和线程池...
C#多线程编程实战完整源码
07-16
C#多线程编程是开发高效、响应迅速的软件应用的关键技术之一，尤其在现代计算环境中，多核处理器和并发处理的需求日益增加。本资源"《C#多线程编程实战》完整源码"提供了丰富的实例，适用于学习和实践C#中的多线程...
C#多线程编程实战.pdf
05-04
C#多线程编程实战.pdf
c#多线程编程实战（原书第二版）源码
06-21
《C#多线程编程实战（原书第二版）源码》是一本深入探讨C#中多线程技术的专业书籍，其源码提供了丰富的实践示例，帮助读者掌握并发编程的核心概念和技术。在C#中，多线程是实现高性能、响应式应用程序的关键组成部分...
用于生成路线的 语音文件
最新发布
12-27
用于生成路线的 语音文件
jdk1.8.0-201.rar
12-27
先展示下效果 https://pan.quark.cn/s/a4b39357ea24 Dart2JS is the Dart-to-JavaScript compiler for Dart. This compiler will provide high-quality translation from Dart to JavaScript. Some areas that will explored in this project are: * high-performance extensible scanner and parser * concrete type inferencing * fancy language tool support * programming environment integration * SSA-based intermediate representation * adaptive compilation on the client
deep-person-reid-master.zip
12-27
行人重识别（Person Re-identification也称行人再识别，简称为ReID，是利用计算机视觉技术判断图像或者视频序列中是否存在特定行人的技术；或者说，行人重识别是指在已有的可能来源与非重叠摄像机视域的视频序列中识别出目标行人。广泛被认为是一个图像检索的子问题。给定一个监控行人图像，检索跨设备下的该行人图像。在监控视频中，由于相机分辨率和拍摄角度的缘故，通常无法得到质量非常高的人脸图片。当人脸识别失效的情况下，ReID就成为了一个非常重要的替代品技术。ReID有一个非常重要的特性就是跨摄像头，所以学术论文里评价性能的时候，是要检索出不同摄像头下的相同行人图片。
【电力系统优化调度】计及源荷两侧不确定性的含风电电力系统低碳调度（Matlab代码实现）
12-27
【电力系统优化调度】计及源荷两侧不确定性的含风电电力系统低碳调度（Matlab代码实现）
ACM算法竞赛题解与优化技巧 练习题
12-27
ACM算法竞赛题解与优化技巧
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值