多线程学习笔记2 线程池
在多线程的程序中，经常会出现两种情况：
一种情况： 应用程序中，线程把大部分的时间花费在等待状态，等待某个事件发生，然后才能给予响应
这一般使用ThreadPool（线程池）来解决；
另一种情况：线程平时都处于休眠状态，只是周期性地被唤醒
这一般使用Timer（定时器）来解决；
ThreadPool类提供一个由系统维护的线程池（可以看作一个线程的容器），该容器需要 Windows 2000 以上系统支持，因为其中某些方法调用了只有高版本的Windows才有的API函数。
将线程安放在线程池里，需使用ThreadPool.QueueUserWorkItem()方法，该方法的原型如下：
//将一个线程放进线程池，该线程的Start()方法将调用WaitCallback代理对象代表的函数
public static bool QueueUserWorkItem(WaitCallback);
//重载的方法如下，参数object将传递给WaitCallback所代表的方法
public static bool QueueUserWorkItem(WaitCallback, object);
注意：
ThreadPool类是一个静态类，你不能也不必要生成它的对象。而且一旦使用该方法在线程池中添加了一个项目，那么该项目将是无法取消的。
在这里你无需自己建立线程，只需把你要做的工作写成函数，然后作为参数传递给 ThreadPool.QueueUserWorkItem()方法就行了，传递的方法就是依靠WaitCallback代理对象，而线程的建立、管理、运行等工作都是由系统自动完成的，你无须考虑那些复杂的细节问题。
ThreadPool 的用法：
首先程序创建了一个ManualResetEvent对象，该对象就像一个信号灯，可以利用它的信号来通知其它线程。
本例中，当线程池中所有线程工作都完成以后，ManualResetEvent对象将被设置为有信号，从而通知主线程继续运行。
ManualResetEvent对象有几个重要的方法：
初始化该对象时，用户可以指定其默认的状态（有信号/无信号）；
在初始化以后，该对象将保持原来的状态不变，直到它的Reset()或者Set()方法被调用：
Reset()方法：将其设置为无信号状态；
Set()方法：将其设置为有信号状态。
WaitOne()方法：使当前线程挂起，直到ManualResetEvent对象处于有信号状态，此时该线程将被激活。然后，程序将向线程池中添加工作项，这些以函数形式提供的工作项被系统用来初始化自动建立的线程。当所有的线程都运行完了以后，ManualResetEvent.Set()方法被调用，因为调用了ManualResetEvent.WaitOne()方法而处在等待状态的主线程将接收到这个信号，于是它接着往下执行，完成后边的工作。
using System.Collections;
using System.Text;
using System.Threading;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Thread Spool Test:");
//新建ManualResetEvent对象并且初始化为无信号状态
ManualResetEvent enve = new ManualResetEvent(false);
int Maxcount = 10;//允许线程池中运行最多10个线程
Test TEST = new Test(Maxcount);
TEST.eventx = enve;
for(int i=0;i<10;i++)
{
Console.WriteLine("Queue to Thread Pool {0}", i);
//线程池自动创建线程 我们只需要传入方法
ThreadPool.QueueUserWorkItem(new WaitCallback(TEST.Bate), new NUmber(i));
}
Console.WriteLine("Waiting for Thread Pool to drain");
//等待事件的完成，即线程调用ManualResetEvent.Set()方法
enve.WaitOne(Timeout.Infinite, true);
//WaitOne()方法使调用它的线程等待直到eventX.Set()方法被调用
Console.WriteLine("Thread Pool has been drained (Event fired)");
Console.WriteLine();
Console.WriteLine("Load across threads");
foreach (object o in TEST.threadhx.Keys)
Console.WriteLine("{0} {1}", o, TEST.threadhx[o]);
Console.ReadLine();
}
}
/// <summary>
/// 传递参数对象
/// </summary>
public class NUmber
{
public int cookie = 0;
public NUmber(int _cookie)
{
cookie = _cookie;
}
}
public class Test
{
public Hashtable threadhx;
public ManualResetEvent eventx;
int icount = 0;
int Maxcount = 0;
public Test(int _Maxcount)
{
threadhx = new Hashtable(_Maxcount);
Maxcount = _Maxcount;
}
public void Bate(object obj)
{
//Console.WriteLine(((NUmber)obj).cookie);//得到传递过来的参数
Console.WriteLine("Hashcount={0},CurrentThread={1}",threadhx.Count,Thread.CurrentThread.GetHashCode());
lock(threadhx)
{
//如果有新的线程就放到列表里面
if (!threadhx.ContainsKey(Thread.CurrentThread.GetHashCode()))
threadhx.Add(Thread.CurrentThread.GetHashCode(),0);
}
threadhx[Thread.CurrentThread.GetHashCode()]= (int)threadhx[Thread.CurrentThread.GetHashCode()] + 1;
//阻止当前线程
int ix = 2000;
Thread.Sleep(ix);
//原子操作 icount++
Interlocked.Increment(ref icount);
//Console.WriteLine(icount);
if(icount==Maxcount)
{
Console.WriteLine("Setting event");
eventx.Set();
}
}
}
}
程序出现的InterLocked类也是专为多线程程序而存在的，它提供了一些有用的原子操作。
原子操作：就是在多线程程序中，如果这个线程调用这个操作修改一个变量，那么其他线程就不能修改这个变量了，这跟lock关键字在本质上是一样的。
如果设计一个服务器程序，每当处理用户请求时，都开始一个线程，将会在一定程序上消 耗服务器的资源。为此，一个最好的解决方法就是在服务器启动之前，事先创建一些线程对象，然后，当处理客户端请求时，就从这些建好的线程中获得线程对象， 并处理请求。保存这些线程对象的结构就叫做线程池。
下面的程序是我设计的一个下载文件服务器的例子。这个例子从ThreadPool获得线程，并处理相应的客户端请求。
代码using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Net.Sockets;
using System.IO;
namespace MyThread
{
class FileServer
{
private String root;
private Thread listenerThread;
private void worker(object state)
{
TcpClient client = state as TcpClient;
try
{
client.ReceiveTimeout = 2000;
Stream stream = client.GetStream();
System.IO.StreamReader sr = new StreamReader(stream);
String line = sr.ReadLine();
String[] array = line.Split(' ');
String path = array[1].Replace('/', '\\');
String filename = root + path;
if (File.Exists(filename)) // 如果下载文件存在，开始下载这个文件
{
FileStream fileStream = new FileStream(filename, FileMode.Open, FileAccess.Read,
FileShare.Read);
byte[] buffer = new byte[8192]; // 每次下载8K
int count = 0;
String responseHeader = "HTTP/1.1 200 OK\r\n" +
"Content-Type:application/octet-stream\r\n" +
"Content-Disposition:attachment;filename=" +
filename.Substring(filename.LastIndexOf("\\") + 1) + "\r\n\r\n";
byte[] header = ASCIIEncoding.ASCII.GetBytes(responseHeader);
stream.Write(header, 0, header.Length);
while ((count = fileStream.Read(buffer, 0, buffer.Count())) > 0)
{
stream.Write(buffer, 0, count);
}
Console.WriteLine(filename + "下载完成");
}
else // 文件不存在，输出提示信息
{
String response = "HTTP/1.1 200 OK\r\nContent-Type:text/plain;charset=utf-8\r\n\r\n文件不存在";
byte[] buffer = ASCIIEncoding.UTF8.GetBytes(response);
stream.Write(buffer, 0, buffer.Length);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
finally
{
if (client != null)
{
client.Close();
}
}
}
private void listener()
{
TcpListener listener = new TcpListener(1234);
listener.Start(); // 开始监听客户端请求
TcpClient client = null;
while (true)
{
client = listener.AcceptTcpClient();
client.ReceiveTimeout =2000;
ThreadPool.QueueUserWorkItem(worker, client); // 从线程池中获得一个线程来处理客户端请求
}
}
public FileServer(String root)
{
this.root= root;
}
public void start()
{
listenerThread = new Thread(listener);
listenerThread.Start(); // 开始运行监听线程
}
}
}
