[.Net线程处理系列]专题三：线程池中的I/O线程

素颜马尾好姑娘i 2022-09-20 12:39 162阅读 0赞

上一篇文章主要介绍了如何利用线程池中的工作者线程来实现多线程，使多个线程可以并发地工作，从而高效率地使用系统资源。在这篇文章中将介绍如何用线程池中的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,intbufferSize,bool useAsync)

其中path代表文件的相对路径或绝对路径，mode代表如何打开或创建文件，access代表访问文件的方式，share代表文件如何由进程共享，buffersize代表缓冲区的大小，useAsync代表使用异步I/O还是同步I/O,设置为true时，说明使用异步I/O.

下面通过代码来学习下异步写入文件：

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());  
                }  
            }

运行结果： ![2012071915015237.png][]

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

下面演示如何从刚才的文件中异步读取我们写入的内容：

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());  
                }  
            }  
        }

运行结果： ![2012071916205525.png][]

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

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

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

下面就来演示下如何实现请求异步：

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());  
                }  
            }  
        }

运行结果为： ![2012071916523183.png][]

三、小结

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

本文出自 “[LearningHard][]” 博客，请务必保留此出处[http://learninghard.blog.51cto.com/6146675/1034790][http_learninghard.blog.51cto.com_6146675_1034790]

[2012071915015237.png]: /images/20220828/8a7823be43aa46fdbc784c49a74ffdd9.png
[2012071916205525.png]: /images/20220828/662141f389c0441684eac5c71af7f5c0.png
[2012071916523183.png]: /images/20220828/1740fcb5cd4449f1982395e9b0ec7329.png
[LearningHard]: http://learninghard.blog.51cto.com/
[http_learninghard.blog.51cto.com_6146675_1034790]: http://learninghard.blog.51cto.com/6146675/1034790