因为有些人可能会疑惑，将了这么多多线程，到底在实际的应用上有什么作用的呢？ 这里我在这里用多线程简单实现了一个文件的下载的功能。



服务器端页面：
```csharp
<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="FileServer.Default" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
 <title></title>
</head>
<body> 
 <form id="form1" runat="server">
 <div>
 
 <asp:Image ID="Image1" runat="server" ImageUrl="~/Images/1.gif" />
 
 说明： CLR Via C#
 </div>
 
 </form>
</body>
</html>
```
服务器页面只是一个简单显示需要下载文件的一些信息，这里通过Handler.ashx来处理文件的下载，把文件的转化为二进制字节写入到输出流中，具体实现代码为：
```csharp
public class Handle : IHttpHandler
{
 public void ProcessRequest(HttpContext context)
 {
 HttpResponse response = context.Response;
 HttpRequest request = context.Request;
 FileStream fileStream = null;
 byte[] buffer = new Byte[10240];
 int length;

 // 剩余的字节大小
 // 因为这里采取的是每次写入10240字节到输出流中
 long readToData;
 try
 {
 string filename = "CLR via CSharp 3rd edition.pdf"; //通过解密得到文件名

 string filepath = HttpContext.Current.Server.MapPath("~/") + "Resources/" + filename; //待下载的文件路径

 fileStream = new FileStream(filepath, FileMode.Open,FileAccess.Read, FileShare.Read);
 readToData = fileStream.Length;
 while (readToData > 0)
 {
 // 实际读取的字节大小
 length = fileStream.Read(buffer, 0, buffer.Length);
 // 把读取到的字节写入输出流中
 response.OutputStream.Write(buffer, 0, length);
 response.Flush();
 readToData = readToData - length;
 }
 }
 catch (Exception ex)
 {
 response.Write("Error:" + ex.Message);
 }
 finally
 {
 if (fileStream != null)
 {
 fileStream.Close();
 }

 response.End();
 }
 }

 public bool IsReusable
 {
 get
 {
 return false;
 }
 }
}
```
这里牵涉到HttpHandle对象问题，这个对象在Asp.net中是真正处理数据的对象，后面如果有时间也和大家分享下深入理解Asp.net系列，主要是介绍在Asp.net中一些核心对象为我们默默做的一些事情，在这里也不详细介绍HttpHandle对象了， 这个示例中主要通过这个类来对文件的处理，把文件的二进制字节写入到输出流中， 客户端在从输出流中读取字节，然后保存为文件（其实文件也就是“流”）。

客户端：
客户端建立了一个WinForm窗口，通过WebBrower控件（就是在WinForm程序中显示网页的控件）来连接服务器页面，当按下下载按钮后，通过线程池线程来执行下载方法。主要代码为：

```csharp
public void DownLoad(object state)
{
 // 计时对象
 Stopwatch sw = Stopwatch.StartNew();

 HttpWebRequest request;
 HttpWebResponse response;
 Stream stream;

 // 下载下来的保存的地址
 string savepath = "D:\\Download.pdf";
 FileStream savestream = new FileStream(savepath, FileMode.OpenOrCreate);
 try
 {
 // 发出请求
 request = (HttpWebRequest)HttpWebRequest.Create(url);

 // 获得回应对象
 response = (HttpWebResponse)request.GetResponse();

 // 获得回应流
 stream = response.GetResponseStream();
 byte[] bytes = new byte[10240];
 int readsize;

 // 每次都读取10240字节
 // 采用的是同步读取方法
 // 计算耗费的时间 
 readsize = stream.Read(bytes, 0, bytes.Length);
 while (readsize > 0)
 {
 savestream.Write(bytes, 0, readsize);
 readsize = stream.Read(bytes, 0, bytes.Length);
 }

 sw.Stop();
 MessageBox.Show("下载耗时为：" + sw.Elapsed.ToString(), "提示");
 }
 catch (Exception ex)
 {
 MessageBox.Show(ex.Message, "Error");
 }
 finally
 {
 savestream.Close();
 }
}
```
这样就利用线程池线程简单完成了客户端下载服务器端文件的功能，并且使用线程池线程这样不会主线程，从而导致在下载文件时，界面同样可以操作，如果不采用多线程操作的话将会在下载过程导致界面“卡死”现象，这样就会给用户带来不好的用户体验。

其实本来还想做复杂点的， 开始想实现的功能，是服务器端断点续传，然后客户端多线程下载的功能的，这个示例中只用到了一个线程池线程来完成下载任务，本来想通过执行多个线程池线程来完成下载任务的， 每个线程只负责一部分的读取工作， 然后把每个线程中读取的字节合并起来就是完整的文件字节了，但是这里遇到一个问题，怎么在服务器端实现续传的功能的， 客户端通过AddRange方法来发出部分读取请求，然后服务器端就要对请求头Range进行解析的，实现原理我还是清楚，但是在做的过程中还是出现了问题。所以这里只能分享一个简单的下载文件的功能给大家了， 至于多线程的下载和断点续传和大文件的上传等问题，等我学习了再和大家分享， 如果有大牛可以帮助我解决服务端断点续传的问题的话，欢迎留言。 源文件下载链接：[https://files.cnblogs.com/zhili/FileServer.zip](https://files.cnblogs.com/zhili/FileServer.zip) （下载下来后只需要在服务器端Resources文件夹下添加一个文件就可以运行了）

> 来自: [[C# 多线程处理系列专题七——对多线程的补充 - Learning hard - 博客园](https://www.cnblogs.com/zhili/archive/2012/07/28/FileDownLoad.html)

[C# 线程处理系列]专题七：对多线程的补充

也不多说了，直接进入主题了

**一、信号量（Semaphore）**

信号量（Semaphore）是由内核对象维护的int变量，当信号量为0时，在信号量上等待的线程会堵塞，信号量大于0时，就解除堵塞。当在一个信号量上等待的线程解除堵塞时，内核自动会将信号量的计数减1。在.net 下通过Semaphore类来实现信号量同步。

Semaphore类限制可同时访问某一资源或资源池的线程数。线程通过调用 WaitOne方法将信号量减1，并通过调用 Release方法把信号量加1。



先说下构造函数：

public Semaphore(int initialCount,int maximumCount);通过两个参数来设置信号的初始计数和最大计数。

下面通过一段代码来演示信号量同步的使用：
```csharp
class Program
{
 // 初始信号量计数为0，最大计数为10
 public static Semaphore semaphore =new Semaphore(0,10);
 public static int time = 0;
 static void Main(string[] args)
 {
 for (int i = 0; i < 5; i++)
 {
 Thread test = new Thread(new ParameterizedThreadStart(TestMethod));

 // 开始线程，并传递参数
 test.Start(i);
 }

 // 等待1秒让所有线程开始并阻塞在信号量上
 Thread.Sleep(500);

 // 信号量计数加4
 // 最后可以看到输出结果次数为4次
 semaphore.Release(4);
 Console.Read(); 
 }

 public static void TestMethod(object number)
 {
 // 设置一个时间间隔让输出有顺序
 int span = Interlocked.Add(ref time, 100);
 Thread.Sleep(1000 + span);

 //信号量计数减1
 semaphore.WaitOne();

 Console.WriteLine("Thread {0} run ", number);
 }
}
```
运行结果：

![image.png](https://cdn.netclub.top/images/bbc8445b6d54a4ddaded321609a9ce7b.image.webp?imageslim)
同样信号量也可以实现进程中线程的同步，同样也是通过对信号量命名来实现的， 通过调用public Semaphore(int initialCount,int maximumCount,string name);该构造函数多传入一个信号量名来实现 下面一段实例代码来演示下：
```csharp
using System;
using System.Threading;

namespace SemaphoreSample
{
 class Program
 {
 // 初始信号量计数为4，最大计数为10
 public static Semaphore semaphore =new Semaphore(4,10,"My");
 public static int time = 0;
 static void Main(string[] args)
 {
 for (int i = 0; i < 3; i++)
 {
 Thread test = new Thread(new ParameterizedThreadStart(TestMethod));

 // 开始线程，并传递参数
 test.Start(i);
 }

 // 等待1秒让所有线程开始并阻塞在信号量上
 Thread.Sleep(1000);

 Console.Read(); 
 }

 public static void TestMethod(object number)
 {
 // 设置一个时间间隔让输出有顺序
 int span = Interlocked.Add(ref time, 500);
 Thread.Sleep(1000 + span);

 //信号量计数减1
 semaphore.WaitOne();

 Console.WriteLine("Thread {0} run ", number);
 }
 }
}
```
运行结果：

![image.png](https://cdn.netclub.top/images/3fac9d823d62f539a377240a262e75c3.image.webp?imageslim)
从运行结果中可以看出， 第二个进程值运行了一行语句， 因为我们设置的初始信号计数为4，每运行一个线程，信号计数通过调用WaitOne方法减1,所以第二个进行一开始信号计数为1而不是进程一中的4，如果我们把信号计数后面的name参数去除的话，此时第二个进程和第一个进程中的结果应该是一样的（因为此时没有进行不同进程中线程的同步）。

**二、互斥体（Mutex）**

同样互斥体也是同样可以实现线程之间的同步和不同进程中线程的同步的

先看看线程之间的同步的例子吧（在这里我也不多做解释了，因为他们之间的使用很类似，直接贴出代码）：
```csharp
class Program
{
 public static Mutex mutex = new Mutex();
 public static int count;

 static void Main(string[] args)
 {
 for (int i = 0; i < 10; i++)
 {
 Thread test = new Thread(TestMethod);

 // 开始线程，并传递参数
 test.Start();
 }

 Console.Read();
 }

 public static void TestMethod()
 {
 mutex.WaitOne();
 Thread.Sleep(500);
 count++;
 Console.WriteLine("Current Cout Number is {0}", count);
 mutex.ReleaseMutex();
 }
}
```
运行结果：

![image.png](https://cdn.netclub.top/images/ba6ee6123b8bf4275a6cc37b2b409c2e.image.webp?imageslim)
实现进程间同步：
```csharp
class Program
{
 public static Mutex mutex = new Mutex(false,"My");

 static void Main(string[] args)
 {
 Thread t = new Thread(TestMethod);
 t.Start();

 Console.Read();
 }

 public static void TestMethod()
 {
 mutex.WaitOne();
 Thread.Sleep(5000);
 Console.WriteLine("Method start at : " + DateTime.Now.ToLongTimeString());
 mutex.ReleaseMutex();
 }
}
```
运行结果：

![image.png](https://cdn.netclub.top/images/553a8e0593a90e2a647e61e03d15850a.image.webp?imageslim)
从运行结果看出两个进程之间的时间间隔为5秒，当我们把构造函数中命名参数去掉时就可以看出差别了。

到这里多线程处理基本上讲完，这个系列也只是一个入门，真真要好好掌握多线程，还是要在项目中多去实战的。接下来我可能会做一个小的例子的，大概的思路是实现一个文件的下载的这样的例子。如果大家有什么好的例子来运用多线程的知识的话，可以留言给我，我也会尽量去实现（如果不会的话，这样也可以促使我去学习），实现后也会和大家分享的。

> 来自: [[C# 线程处理系列]专题六：线程同步——信号量和互斥体 - Learning hard - 博客园](https://www.cnblogs.com/zhili/archive/2012/07/23/Mutex_And_Semaphore.html)

[C# 线程处理系列]专题六：线程同步--信号量和互斥体

> 引言：

其实这部分内容应该是属于专题四，因为这篇也是讲关于线程同步的，但是由于考虑到用户的阅读习惯问题，因为文章太长了，很多人不是很愿意看包括我也是这样的，同时也有和我说可以把代码弄成折叠的，这样就不会太长的，但是我觉得这样也不怎么便于阅读，因为我看别人的博客的时候，看到有代码是折叠起来的时候很多时候不愿意去点，并且点一下之后同样拉长文章的，然后就看到右边的滚动条变小了，本以为快看完了(意思快学到知识了)，一看滚动条后发现还有好长的内容很看， 所以就会给人一种不舒服的感觉吧(如果有和我一样的人的话，你肯定懂的是什么感觉的)。

所以我把线程同步放到两篇文章里面来说，其实放到两篇文章里面也有一定原因的， 前面讲的线程同步主要是用户模式的(CLR Via C# 一书中是这么定义的，书中说到线程同步分两种：一、用户模式构造 二、内核模式构造，第一次看的时候不是很理解两个名词是什么意思的，我一般理解东西是采用把东西拆分来理解，理解拆分的各个部分后再合起来理解内容的，现在我对着两个的理解是——用户模式构造：对于内核模式构造（指的的是构造操作系内核对象），我们使用类（.net Framework中的类，如 AutoResetEvent, Semaphore类）的方法来实现线程同步，其实内部是调用操作系统的内核对象来实现的线程同步，此时就会导致线程从托管代码到为内核代码，然而用户模式构造，没有调用操作系统内核对象，线程只是在用户的托管代码上执行的)，对于用户模式构造和内核模式的构造只是我自己的理解的， 如果有更好的理解方式可以留言告诉下我， 这样我们可以一起讨论和学习了。


目录：

一、WaitHandle基类介绍

二、事件(Event)类实现线程同步

三、信号量(Semapyore)类实现线程同步

四、互斥体(Mutex)实现线程同步

**一、WaitHandle基类介绍**

**System.Threading**命名空间中提供了一个**WaitHandle **的抽象基类，此类就是包装了一个Windows内核对象的句柄（句柄可以理解为标示了对象实例的一个数字，具体大家可以查看资料深入理解下的，在这里只是提出理解句柄也是很重要的）,在.net Framework中提供了从WaitHandle类中派生的类（我正是用这些派生类在我们的代码中实现线程同步的）。
它们的一个继承关系为 
**WaitHandle** 
**EventWaitHandle** 
**AutoResetEvent** 
**ManualResetEvent** 
**Semaphore** 
**Mutex** 
当我们在使用 **AutoResetEvent**,**ManualResetEvent,Semaphore,Mutex**这些类的时候，用构造函数来实例化这些类的对象时，其内部都调用了Win32 CreateEvent或CreateEvent函数，或CreateSemaphore或者CreateMutex函数，这些函数调用返回的句柄值都保存在WaitHandle基类定义的SafeWaitHandle字段中。

**二、事件(Event)类实现线程同步**

**2.1 AutoResetEvent （自动重置事件）**

先讲讲AutoresetEvent类的构造函数，其定义为： 
public AutoResetEvent(bool initialState); 
构造函数中用一个bool 类型的初始状态来设置AutoResetEvent对象的状态，如果要将AutoResetEvent对象的初始状态设置为终止，则传入bool值为true，若要设置非终止，就传入false。 
WaitOne方法定义： 
public virtual bool WaitOne(int millisecondsTimeout）;该方法用来阻塞线程，当在指定的时间间隔还没有收到一个信号时，将返回false。 
调用Set方法发信号来释放等待线程。在使用过程中WaitOne方法和Set方法都是成对出现的， 一个用于阻塞线程，等待信号，一个用来释放等待线程(就是说调用set方法来发送一个信号，此时WaitOne接受到信号，就释放阻塞的线程，线程就可以继续运行) 
线程通过调用AutoResetEvent的WaitOne方法来等待信号，如果AutoResetEvent对象为非终止状态，则线程被阻止，等到线程调用Set方法来恢复线程执行。如果AutoResetEvent为终止状态时，则线程不会被阻止，此时AutoResetEvent将立即释放线程并返回为非终止状态（指出有线程在使用资源的一种状态）。 
下面通过通过一个例子来演示下AutoResetEvent的使用：

```csharp
using System;
using System.Threading;

namespace KenelMode
{
 class Program
 {
 // 初始化自动重置事件，并把状态设置为非终止状态
 // 如果这里把初始状态设置为True时，
 // 当调用WaitOne方法时就不会阻塞线程,看到的输出结果的时间就是一样的了
 // 因为设置为True时，表示此时已经为终止状态了。 
 public static AutoResetEvent autoEvent = new AutoResetEvent(false);
 static void Main(string[] args)
 {
 Console.WriteLine("Main Thread Start run at: " +DateTime.Now.ToLongTimeString());
 Thread t = new Thread(TestMethod);
 t.Start();

 // 阻塞主线程3秒后
 // 调用 Set方法释放线程，使线程t可以运行
 Thread.Sleep(3000);

 // Set 方法就是把事件状态设置为终止状态。
 autoEvent.Set();
 Console.Read();
 }

 public static void TestMethod()
 {
 autoEvent.WaitOne();

 // 3秒后线程可以运行，所以此时显示的时间应该和主线程显示的时间相差3秒
 Console.WriteLine("Method Restart run at: " + DateTime.Now.ToLongTimeString());
 }
 }
}
```
运行结果（从运行结果看确实是过了一秒后在TestMethod方法中的语句）：

![image.png](https://cdn.netclub.top/images/2f556a1eb0e7ae8da80b281ac23fb104.image.webp?imageslim)
上面中用到的是没有带参数的WaitOne方法，该方法表示无限制阻塞线程，直到收到一个事件为止（通过Set方法来发送一个信号），同时我们也可以设置堵塞线程的事件，当超时时，线程将不阻塞直接运行（尽管此时没有通过Set来发送一个信号，线程照样运行，只是WaitOne方法返回的的值不一样）。 
bool WaitOne(int millisecondsTimeout) 收到信号时返回为True,没收到信号返回为false。 
看完下面的代码你可能会形象理解WaitOne(millisecondsTimeout)方法的使用的：
```csharp
using System;
using System.Threading;

namespace KenelMode
{
 class Program
 {
 // 初始化自动重置事件，并把状态设置为非终止状态
 // 如果这里把初始状态设置为True时，
 // 当调用WaitOne方法时就不会阻塞线程,看到的输出结果的时间就是一样的了
 // 因为设置为True时，表示此时已经为终止状态了。 
 public static AutoResetEvent autoEvent = new AutoResetEvent(false);
 static void Main(string[] args)
 {
 Console.WriteLine("Main Thread Start run at: " +DateTime.Now.ToLongTimeString());
 Thread t = new Thread(TestMethod);
 t.Start();

 // 阻塞主线程1秒后
 // 调用 Set方法释放线程，使线程t可以运行
 Thread.Sleep(3000);

 // Set 方法就是把事件状态设置为终止状态。
 autoEvent.Set();
 Console.Read();
 }

 public static void TestMethod()
 {
 if (autoEvent.WaitOne(2000))
 {
 Console.WriteLine("Get Singal to Work");
 // 3秒后线程可以运行，所以此时显示的时间应该和主线程显示的时间相差一秒
 Console.WriteLine("Method Restart run at: " + DateTime.Now.ToLongTimeString());
 }
 else
 {
 Console.WriteLine("Time Out to work");
 Console.WriteLine("Method Restart run at: " + DateTime.Now.ToLongTimeString());
 }
 }
 }
}
```
运行结果：

![image.png](https://cdn.netclub.top/images/d7d2f7f58283b6551822a95b2fc21077.image.webp?imageslim)
同时这里可以把Thread.Sleep(3000)改成Thread.Sleep(1000)的时候，就是说AutoResetEvent对象在超时之前就接到信号了， 此时WaitOne(2000)放回的值就是True,就得到的是Get Singal to Work, 之间的事件间隔当然也是1秒了，在这里结果就不贴了。

**2.2 ManualResetEvent(手动重置事件)**

ManualResetEvent的使用和AutoResetEvent的使用很类似，因为他们都是从EventWaitHandle类派生的，不过他们还是有点区别: AutoResetEvent 为终止状态时线程调用 WaitOne，则线程不会被阻止。**AutoResetEvent 将立即释放线程并返回到非终止状态,当再次调用WaitOne状态时线程会被阻止** **这里请注意如果AutoResetEvent初始为非终止状态时， 调用WaitOne(int millisecondsTimeout)方法后并不会把状态返回为终止状态，此时还是非终止的，调用WaitOne方法自动改变状态只针对初始状态为终止状态时有效。** 
然而ManualResetEvent初始状态为终止状态时时调用WaitOne，则线程同样不会被阻止，**但是ManualResetEvent的状态不会发生改变（当我再次调用WaitOne方法是一样不会阻止线程），需要我们手动终止()** 
下面通过一段代码来说明两者的区别：

```csharp
using System;
using System.Threading;

namespace ManualResetEventSample
{
 class Program
 {
 // 初始化自动重置事件，并把状态设置为终止状态
 public static AutoResetEvent autoEvent = new AutoResetEvent(true);

 ////public static ManualResetEvent autoEvent = new ManualResetEvent(true);
 static void Main(string[] args)
 {
 Console.WriteLine("Main Thread Start run at: " + DateTime.Now.ToLongTimeString());
 Thread t = new Thread(TestMethod);
 t.Start();
 Console.Read();
 }

 public static void TestMethod()
 {
 // 初始状态为终止状态，则第一次调用WaitOne方法不会堵塞线程
 // 此时运行的时间间隔应该为0秒，但是因为是AutoResetEvent对象
 // 调用WaitOne方法后立即把状态返回为非终止状态。
 autoEvent.WaitOne();
 Console.WriteLine("Method start at : "+ DateTime.Now.ToLongTimeString());

 // 因为此时AutoRestEvent为非终止状态，所以调用WaitOne方法后将阻塞线程1秒，这里设置了超时时间
 // 所以下面语句的和主线程中语句的时间间隔为1秒
 // 当时 ManualResetEvent对象时，因为不会自动重置状态
 // 所以调用完第一次WaitOne方法后状态仍然为非终止状态,所以再次调用不会阻塞线程，所以此时的时间间隔也为0
 // 如果没有设置超时时间的话，下面这行语句将不会执行
 autoEvent.WaitOne(1000);
 Console.WriteLine("Method start at : " + DateTime.Now.ToLongTimeString());


 }
 }
}
```
运行结果：

![image.png](https://cdn.netclub.top/images/653200464d32c14d7e1638d8e024fc2a.image.webp?imageslim)
如果你把创建事件为手动重置事件ManualResetEvent时，得到的运行结果就会下面这样：
![image.png](https://cdn.netclub.top/images/84ce9c49723ce659bcbff5a6bd0b0b1c.image.webp?imageslim)

**2.3 跨进程之间同步**

内核模式的构造可同步在同一台机器上的不同进程中运行的线程，所以我们同样可以使用 AutoResetEvent实现不同进程中运行的线程同步，但是此时需要对AutoResetEvent进行命名，但是AutoResetEvent只提供带一个参数的构造函数的，此时应该如何去实现不同进程中的线程同步的呢？ 
其实是有解决办法的，因为AutoResetEvent是继承自EventWaitHandle类的，EventWaitHandle类有多个构造函数的 
除了之前的方法创建AutoResetEvent对象外， 
还可以通过EventWaitHandle AutoEvent = new EventWaitHandle (false, EventResetMode.Auto);这样的方法来构造AutoResetEvent对象，通过 
EventWaitHandle autoEvent = new EventWaitHandle (false, EventResetMode.Auto,"My");方式就可以指定名称了 
下面一段代码演示如何实现跨不同进程中的线程同步：
```csharp
using System;
using System.Threading;

namespace CrossProcess_EventWaitHandle
{
 class Program
 {
 public static EventWaitHandle autoEvent = new EventWaitHandle(true, EventResetMode.AutoReset, "My");
 static void Main(string[] args)
 {
 Console.WriteLine("Main Thread Start run at: " + DateTime.Now.ToLongTimeString());
 Thread t = new Thread(TestMethod);

 // 为了有时间启动另外一个线程
 Thread.Sleep(2000);
 t.Start();
 Console.Read();
 }

 public static void TestMethod()
 {
 // 进程一：显示的时间间隔为2秒
 // 进程二中显示的时间间隔为3秒
 // 因为进程二中AutoResetEvent的初始状态为非终止的
 // 因为在进程一中通过WaitOne方法的调用已经把AutoResetEvent的初始状态返回为非终止状态了
 autoEvent.WaitOne(1000);
 Console.WriteLine("Method start at : "+ DateTime.Now.ToLongTimeString());
 }
 }
}
```
运行结果：

![image.png](https://cdn.netclub.top/images/145a887d32634e54b7d0b7a0ab3d95cd.image.webp?imageslim)
本来打算在一篇文章里面讲述内核模式构造的，写着写着滚动条又变很小了，为了大家的阅读，我把信号量和互斥体放在后面一篇文章里面讲吧，相信后面的内容会很好理解的，因为后面两个类的使用和这篇中讲到的使用很类似，好歹都是继承WaitHandle类的。

> 来自: [[C# 线程处理系列]专题五：线程同步——事件构造 - Learning hard - 博客园](https://www.cnblogs.com/zhili/archive/2012/07/23/Event_Constructor.html)

[C# 线程处理系列]专题五：线程同步--事件构造

目录：

一、线程同步概述

二、线程同步的使用

三 、总结



**一、线程同步概述**

前面的文章都是讲创建多线程来实现让我们能够更好的响应应用程序，然而当我们创建了多个线程时，就存在多个线程同时访问一个共享的资源的情况，在这种情况下，就需要我们用到线程同步，线程同步可以防止数据（共享资源）的损坏。 
然而我们在设计应用程序还是要尽量避免使用线程同步， 因为线程同步会产生一些问题：
1. 它的使用比较繁琐。因为我们要用额外的代码把多个线程同时访问的数据包围起来，并获取和释放一个线程同步锁，如果我们在一个代码块忘记获取锁，就有可能造成数据损坏。
2. 使用线程同步会影响性能，获取和释放一个锁肯定是需要时间的吧，因为我们在决定哪个线程先获取锁时候， CPU必须进行协调，进行这些额外的工作就会对性能造成影响
3. 因为线程同步一次只允许一个线程访问资源，这样就会阻塞线程，阻塞线程会造成更多的线程被创建，这样CPU就有可能要调度更多的线程，同样也对性能造成了影响。

所以在实际的设计中还是要尽量避免使用线程同步，因此我们要避免使用一些共享数据，例如静态字段。

**二、线程同步的使用**

**2.1 对于使用锁性能的影响**

上面已经说过使用锁将会对性能产生影响， 下面通过比较使用锁和不使用锁时消耗的时间来说明这点

```csharp
using System;
using System.Diagnostics;
using System.Threading;

namespace InterlockedSample
{
 // 比较使用锁和不使用锁锁消耗的时间
 // 通过时间来说明使用锁性能的影响
 class Program
 {
 static void Main(string[] args)
 {
 int x = 0;
 // 迭代次数为500万
 const int iterationNumber = 5000000; 
 // 不采用锁的情况
 // StartNew方法 对新的 Stopwatch 实例进行初始化，将运行时间属性设置为零，然后开始测量运行时间。
 Stopwatch sw = Stopwatch.StartNew();
 for (int i = 0; i < iterationNumber; i++)
 {
 x++;
 }

 Console.WriteLine("Use the all time is :{0} ms", sw.ElapsedMilliseconds);

 sw.Restart();
 // 使用锁的情况
 for (int i = 0; i < iterationNumber; i++)
 {
 Interlocked.Increment(ref x);
 }

 Console.WriteLine("Use the all time is :{0} ms", sw.ElapsedMilliseconds);
 Console.Read();
 }
 }
}
```
运行结果（这是在我电脑上运行的结果）从结果中可以看出加了锁的运行速度慢了好多（慢了11倍 197/18 ）：

![image.png](https://cdn.netclub.top/images/e47c53e1d6c5ecb512216eb9338ab7a5.image.webp?imageslim)

**2.2 Interlocked实现线程同步**

Interlocked类提供了为多个线程共享的变量提供原子操作，当我们在多线程中对一个整数进行递增操作时，就需要实现线程同步。 
因为增加变量操作（++运算符）不是一个原子操作，需要执行下列步骤： 
1）将实例变量中的值加载到寄存器中。 
2）增加或减少该值。 
3）在实例变量中存储该值。 
如果不使用 **Interlocked.Increment**方法，线程可能会在执行完前两个步骤后被抢先。然后由另一个线程执行所有三个步骤，此时第一个线程还没有把变量的值存储到实例变量中去，而另一个线程就可以把实例变量加载到寄存器里面读取了（此时加载的值并没有改变），所以会导致出现的结果不是我们预期的，相信这样的解释可以帮助大家更好的理解**Interlocked.Increment**方法和 原子性操作， 
下面通过一段代码来演示下加锁和不加锁的区别（开始讲过加锁会对性能产生影响，这里将介绍加锁来解决线程同步的问题，得到我们预期的结果）： 
不加锁的情况：
```csharp
class Program
{
 static void Main(string[] args)
 { 
 for (int i = 0; i < 10; i++)
 	{
 	Thread testthread = new Thread(Add);
 	testthread.Start();
 	}

 Console.Read();
 }

 // 共享资源
 public static int number = 1;

 public static void Add()
 {
 Thread.Sleep(1000);
 Console.WriteLine("the current value of number is:{0}", ++number);
 }
}
```
运行结果（不同电脑上可能运行的结果和我的不一样，但是都是得到不是预期的结果的）：

![image.png](https://cdn.netclub.top/images/ea535ece14f26077872f0278a7e59d7b.image.webp?imageslim)
为了解决这样的问题，我们可以通过使用 **Interlocked.Increment**方法来实现原子的自增操作。 代码很简单，只需要把++number改成Interlocked.Increment(ref number)就可以得到我们预期的结果了，在这里代码和运行结果就不贴了。 
总之**Interlocked**类中的方法都是执行一次原子读取以及写入的操作的。

**2.3 Monitor实现线程同步**

对于上面那个情况也可以通过Monitor.Enter和Monitor.Exit方法来实现线程同步。C#中通过lock关键字来提供简化的语法(lock可以理解为Monitor.Enter和Monitor.Exit方法的语法糖),代码也很简单：

```csharp
using System;
using System.Threading;

namespace MonitorSample
{
 class Program
 {
 static void Main(string[] args)
 {
 for (int i = 0; i < 10; i++)
 {
 Thread testthread = new Thread(Add);
 testthread.Start();
 }

 Console.Read();
 }

 // 共享资源
 public static int number = 1;

 public static void Add()
 {
 Thread.Sleep(1000);
 //获得排他锁
 Monitor.Enter(number);

 Console.WriteLine("the current value of number is:{0}", number++);

 // 释放指定对象上的排他锁。
 Monitor.Exit(number);
 }
 }
}
```
运行结果当然是我们所期望的：
![image.png](https://cdn.netclub.top/images/278649ba21a732dc2f6395da35750b54.image.webp?imageslim)
在 Monitor类中还有其他几个方法在这里也介绍，只是让大家引起注意下，一个Wait方法，很明显Wait方法的作用是：释放某个对象上的锁以便允许其他线程锁定和访问这个对象。第二个就是TryEnter方法，这个方法与Enter方法主要的区别在于是否阻塞当前线程，当一个对象通过Enter方法获取锁，而没有执行Exit方法释放锁，当另一个线程想通过Enter获得锁时，此时该线程将会阻塞，直到另一个线程释放锁为止，而TryEnter不会阻塞线程。具体代码就不不写出来了。

**2.4 ReaderWriterLock实现线程同步**

如果我们需要对一个共享资源执行多次读取时，然而用前面所讲的类实现的同步锁都只允许一个线程允许，所有线程将阻塞，但是这种情况下肯本没必要堵塞其他线程， 应该让它们并发的执行，因为我们此时只是进行读取操作，此时通过ReaderWriterLock类可以很好的实现读取并行。 
演示代码为：
```csharp
using System;
using System.Collections.Generic;
using System.Threading;

namespace ReaderWriterLockSample
{
 class Program
 {
 public static List<int> lists = new List<int>();

 // 创建一个对象
 public static ReaderWriterLock readerwritelock = new ReaderWriterLock();
 static void Main(string[] args)
 {
 //创建一个线程读取数据
 Thread t1 = new Thread(Write);
 t1.Start();
 // 创建10个线程读取数据
 for (int i = 0; i < 10; i++)
 {
 Thread t = new Thread(Read);
 t.Start();
 }

 Console.Read();

 }

 // 写入方法
 public static void Write()
 {
 // 获取写入锁，以10毫秒为超时。
 readerwritelock.AcquireWriterLock(10);
 Random ran = new Random();
 int count = ran.Next(1, 10);
 lists.Add(count);
 Console.WriteLine("Write the data is:" + count);
 // 释放写入锁
 readerwritelock.ReleaseWriterLock();
 }

 // 读取方法
 public static void Read()
 {
 // 获取读取锁
 readerwritelock.AcquireReaderLock(10);

 foreach (int li in lists)
 {
 // 输出读取的数据
 Console.WriteLine(li);
 }

 // 释放读取锁
 readerwritelock.ReleaseReaderLock();
 }
 }
}
```
运行结果：

![image.png](https://cdn.netclub.top/images/38612bb411fa62cd18510bc844c15901.image.webp?imageslim)

**三、总结**

本文中主要介绍如何实现多线程同步的问题， 通过线程同步可以防止共享数据的损坏，但是由于获取锁的过程会有性能损失，所以在设计应用过程中尽量减少线程同步的使用。本来还要介绍互斥(Mutex), 信号量(Semaphore), 事件构造的， 由于篇幅的原因怕影响大家的阅读，所以这剩下的内容放在后面介绍的。 

> 来自: [[C# 线程处理系列]专题四：线程同步 - Learning hard - 博客园](https://www.cnblogs.com/zhili/archive/2012/07/21/ThreadsSynchronous.html)

[C# 线程处理系列]专题四：线程同步

上一篇文章主要介绍了如何利用线程池中的工作者线程来实现多线程，使多个线程可以并发地工作，从而高效率地使用系统资源。在这篇文章中将介绍如何用线程池中的I/O线程来执行I/O操作，希望对大家有所帮助。



**目录：**

一、I/O线程实现对文件的异步

二、I/O线程实现对请求的异步

三、总结


**一、I/O线程实现对文件的异步**

**1.1 I/O线程介绍：**

对于线程所执行的任务来说，可以把线程分为两种类型：工作者线程和I/O线程。 
工作者线程用来完成一些计算的任务，在任务执行的过程中，需要CPU不间断地处理，所以，在工作者线程的执行过程中，CPU和线程的资源是充分利用的。 
I/O线程主要用来完成输入和输出的工作的，在这种情况下， 计算机需要I/O设备完成输入和输出的任务，在处理过程中，CPU是不需要参与处理过程的，此时正在运行的线程将处于等待状态，只有等任务完成后才会有事可做， 这样就造成线程资源浪费的问题。为了解决这样的问题，可以通过线程池来解决这样的问题，让线程池来管理线程，前面已经介绍过线程池了， 在这里就不讲了。 
对于I/O线程，我们可以将输入输出操作分成三个步骤：启动、实际输入输出、处理结果。用于实际输入输出可由硬件完成，并不需要CPU的参与，而启动和处理结果也可以不在同一个线程上，这样就可以充分利用线程资源。在.Net中通过以Begin开头的方法来完成启动，以End开头的方法来处理结果，这两个方法可以运行在不同的线程，这样我们就实现了异步编程了。

**1.2 .Net中如何使用异步**

**注意：**

其实当我们调用Begin开头的方法就是将一个I/O线程排入到线程池中（调用Begin开头的方法就把I/O线程加入到线程池中管理都是.Net机制帮我们实现的）。 
（因为有些人会问什么地方用到了线程池了，工作者线程由线程池管理很好看出来，因为创建工作者线程直接调用**ThreadPool.QueueUserWorkItem**方法来把工作者线程排入到线程池中）。 
在.net Framework中的FCL中有许多类型能够对异步操作提供支持，其中在FileStream类中就提供了对文件的异步操作的方法。 
FileStream类要调用I/O线程要实现异步操作，首先要建立一个FileStream对象。 
通过下面的构造函数来初始化FileStream对象实现异步操作(异步读取和异步写入): 
public FileStream (string path, FileMode mode, FileAccess access, FileShare share,int bufferSize,bool useAsync) 
其中path代表文件的相对路径或绝对路径，mode代表如何打开或创建文件，access代表访问文件的方式，share代表文件如何由进程共享，buffersize代表缓冲区的大小，useAsync代表使用异步I/O还是同步I/O,设置为true时，说明使用异步I/O. 
下面通过代码来学习下异步写入文件：

```csharp
using System;
using System.IO;
using System.Text;
using System.Threading;

namespace AsyncFile
{
 class Program
 {
 static void Main(string[] args)
 {
 const int maxsize = 100000;
 ThreadPool.SetMaxThreads(1000,1000);
 PrintMessage("Main Thread start");

 // 初始化FileStream对象
 FileStream filestream = new FileStream("test.txt", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite, 100, true);

 //打印文件流打开的方式
 Console.WriteLine("filestream is {0} opened Asynchronously", filestream.IsAsync ? "" : "not");

 byte[] writebytes =new byte[maxsize];
 string writemessage = "An operation Use asynchronous method to write message.......................";
 writebytes = Encoding.Unicode.GetBytes(writemessage);
 Console.WriteLine("message size is： {0} byte\n", writebytes.Length);
 // 调用异步写入方法比信息写入到文件中
 filestream.BeginWrite(writebytes, 0, writebytes.Length, new AsyncCallback(EndWriteCallback), filestream);
 filestream.Flush();
 Console.Read();

 }

 // 当把数据写入文件完成后调用此方法来结束异步写操作
 private static void EndWriteCallback(IAsyncResult asyncResult)
 {
 Thread.Sleep(500);
 PrintMessage("Asynchronous Method start");

 FileStream filestream = asyncResult.AsyncState as FileStream;

 // 结束异步写入数据
 filestream.EndWrite(asyncResult);
 filestream.Close();
 }

 // 打印线程池信息
 private static void PrintMessage(String data)
 {
 int workthreadnumber;
 int iothreadnumber;

 // 获得线程池中可用的线程，把获得的可用工作者线程数量赋给workthreadnumber变量
 // 获得的可用I/O线程数量给iothreadnumber变量
 ThreadPool.GetAvailableThreads(out workthreadnumber, out iothreadnumber);

 Console.WriteLine("{0}\n CurrentThreadId is {1}\n CurrentThread is background :{2}\n WorkerThreadNumber is:{3}\n IOThreadNumbers is: {4}\n",
 data,
 Thread.CurrentThread.ManagedThreadId,
 Thread.CurrentThread.IsBackground.ToString(),
 workthreadnumber.ToString(),
 iothreadnumber.ToString());
 }
 }
}
```
运行结果：

![image.png](https://cdn.netclub.top/images/759161a87e1d25d06bc006484967d72a.image.webp?imageslim)

从运行结果可以看出，此时是调用线程池中的I/O线程去执行回调函数的，同时在工程所的的bin\Debug文件目录下有生成一个text.txt文件，打开文件可以知道里面的内容正是你写入的。 下面演示如何从刚才的文件中异步读取我们写入的内容：

```csharp
using System;
using System.IO;
using System.Text;
using System.Threading;

namespace AsyncFileRead
{
 class Program
 {
 const int maxsize = 1024;
 static byte[] readbytes = new byte[maxsize];
 static void Main(string[] args)
 {
 ThreadPool.SetMaxThreads(1000, 1000);
 PrintMessage("Main Thread start");

 // 初始化FileStream对象
 FileStream filestream = new FileStream("test.txt", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite, 100, false);

 // 异步读取文件内容
 filestream.BeginRead(readbytes, 0, readbytes.Length, new AsyncCallback(EndReadCallback), filestream);
 Console.Read();
 }

 private static void EndReadCallback(IAsyncResult asyncResult)
 {
 Thread.Sleep(1000);
 PrintMessage("Asynchronous Method start");

 // 把AsyncResult.AsyncState转换为State对象
 FileStream readstream = (FileStream)asyncResult.AsyncState;
 int readlength = readstream.EndRead(asyncResult);
 if (readlength <=0)
 {
 Console.WriteLine("Read error");
 return;
 }

 string readmessage = Encoding.Unicode.GetString(readbytes, 0, readlength);
 Console.WriteLine("Read Message is :" + readmessage);
 readstream.Close();
 }

 // 打印线程池信息
 private static void PrintMessage(String data)
 {
 int workthreadnumber;
 int iothreadnumber;

 // 获得线程池中可用的线程，把获得的可用工作者线程数量赋给workthreadnumber变量
 // 获得的可用I/O线程数量给iothreadnumber变量
 ThreadPool.GetAvailableThreads(out workthreadnumber, out iothreadnumber);

 Console.WriteLine("{0}\n CurrentThreadId is {1}\n CurrentThread is background :{2}\n WorkerThreadNumber is:{3}\n IOThreadNumbers is: {4}\n",
 data,
 Thread.CurrentThread.ManagedThreadId,
 Thread.CurrentThread.IsBackground.ToString(),
 workthreadnumber.ToString(),
 iothreadnumber.ToString());
 }
 }
}
```
运行结果：

![image.png](https://cdn.netclub.top/images/71ecdb1a5a6e011ac1815576c5440925.image.webp?imageslim)

这里有个需要注意的问题：如果大家测试的时候， 应该把开始生成的text.txt文件放到该工程下bin\debug\目录下， 我刚开始的做的时候就忘记拷过去的， 读出来的数据长度一直为0（这里我犯的错误写下了，希望大家可以注意，也是警惕自己要小心。）

**二、I/O线程实现对请求的异步**

我们同样可以利用I/O线程来模拟对浏览器对服务器请求的异步操作，在.net类库中的WebRequest类提供了异步请求的支持， 
下面就来演示下如何实现请求异步：

```csharp
using System;
using System.Net;
using System.Threading;

namespace RequestSample
{
 class Program
 {
 static void Main(string[] args)
 {
 ThreadPool.SetMaxThreads(1000, 1000);
 PrintMessage("Main Thread start");

 // 发出一个异步Web请求
 WebRequest webrequest =WebRequest.Create("http://www.cnblogs.com/");
 webrequest.BeginGetResponse(ProcessWebResponse, webrequest);

 Console.Read();
 }

 // 回调方法
 private static void ProcessWebResponse(IAsyncResult result)
 {
 Thread.Sleep(500);
 PrintMessage("Asynchronous Method start");

 WebRequest webrequest = (WebRequest)result.AsyncState;
 using (WebResponse webresponse = webrequest.EndGetResponse(result))
 { 
 Console.WriteLine("Content Length is : "+webresponse.ContentLength);
 }
 }

 // 打印线程池信息
 private static void PrintMessage(String data)
 {
 int workthreadnumber;
 int iothreadnumber;

 // 获得线程池中可用的线程，把获得的可用工作者线程数量赋给workthreadnumber变量
 // 获得的可用I/O线程数量给iothreadnumber变量
 ThreadPool.GetAvailableThreads(out workthreadnumber, out iothreadnumber);

 Console.WriteLine("{0}\n CurrentThreadId is {1}\n CurrentThread is background :{2}\n WorkerThreadNumber is:{3}\n IOThreadNumbers is: {4}\n",
 data,
 Thread.CurrentThread.ManagedThreadId,
 Thread.CurrentThread.IsBackground.ToString(),
 workthreadnumber.ToString(),
 iothreadnumber.ToString());
 }
 }
}
```
运行结果为

![image.png](https://cdn.netclub.top/images/c823f650ddd3623f65e1aac0ab2aec37.image.webp?imageslim)

写到这里这篇关于I/O线程的文章也差不多写完了， 其实I/O线程还可以做很多事情，在网络(Socket)编程,web开发中都会用I/O线程，本来想写个Demo来展示多线程在实际的工作中都有那些应用的地方的， 但是后面觉得还是等多线程系列都讲完后再把知识一起串联起来做个Demo会好点，至于后面文章中将介绍下线程同步的问题。

> 来自: [[C# 线程处理系列]专题三：线程池中的I/O线程 - Learning hard - 博客园](https://www.cnblogs.com/zhili/archive/2012/07/20/MultiThreads.html)