Thread Pool 备忘
using System;
using System.Threading;
public class Example 
{
public static void Main() {
// Queue the task.
ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadProc));
ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadProc2));
Console.WriteLine("Main thread does some work, then sleeps.");
// If you comment out the Sleep, the main thread exits before
// the thread pool task runs. The thread pool uses background
// threads, which do not keep the application running. (This
// is a simple example of a race condition.)
Thread.Sleep(1000);
Console.ReadLine();
Console.WriteLine("Main thread exits.");
}
// This thread procedure performs the task.
static void ThreadProc(Object stateInfo) {
// No state object was passed to QueueUserWorkItem, so
// stateInfo is null.
for(int i=0;i<50;i++)
{
Random rnd = new Random();
int n = rnd.Next(100,1000);
Thread.Sleep(n);
Console.WriteLine("AAAAAA."+i.ToString());
}
}
static void ThreadProc2(Object stateInfo) {
// No state object was passed to QueueUserWorkItem, so
// stateInfo is null.
for(int i=0;i<50;i++)
{
Random rnd = new Random();
int n = rnd.Next(100,1000);
Thread.Sleep(n);
Console.WriteLine("BBBB."+i.ToString());
}
}
}转载别人的一个类..
using System;
using System.Threading ;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Collections ;
using System.Text ;
using System.Diagnostics ;
namespace Bigeagle.Net.Server
{
/**//// <summary>
/// <br>server类</br>
/// <br>Author: bigeagle@163.net</br>
/// <br>Date : 2002/02/04</br>
/// <br>History: 2002/02/04 finished</br>
/// <br>Todo: 现在的类结构不尽合理，将来考虑使用delgates以便同winform绑定。</br>
/// </summary>
/// <remarks>
/// <br>抽象类，用于一些常见的网络server的基类，如http,ftp,mail等。</br>
/// <br>主要功能是监听一个端口，然后利用线程池起规定数量的线程等待客户端连接
/// ，同时有一个守护线程监视线程使用情况，如果所有线程都在工作，则起一个空闲线程
/// 继续等待客户端的连接。
/// </br>
/// <br>子类继承后必须实现其OnCommunication()抽象方法来完成自己要做的工作。</br>
/// </remarks>
public abstract class Server
{
常量#region 常量
/**//// <summary>
/// 守护线程工作时间间隔
/// </summary>
/// <remarks>每隔多少毫秒守护线程工作一次</remarks>
const int WATCHING_INTERVAL = 10000 ;
#endregion
静态变量#region 静态变量
/**//// <summary>
/// 目前起的线程数
/// </summary>
static int intThreadCount ;
/**//// <summary>
/// 正在工作的线程数
/// </summary>
static int intWorkThreadCount ;
#endregion
成员变量定义#region 成员变量定义
/**//// <summary>
/// 线程信号
/// </summary>
private AutoResetEvent myEvent ;
private bool m_bIsInitOK ;
/**//// <summary>
/// server名
/// </summary>
protected string m_strServerName ;
/**//// <summary>
/// 退出标志
/// </summary>
protected bool m_bCanExit ;
/**//// <summary>
/// 监听端口号
/// </summary>
protected int m_intPort ;
/**//// <summary>
/// 端口监听
/// </summary>
protected TcpListener m_objListener ;
/**//// <summary>
/// 守护线程
/// </summary>
protected Thread m_objWatchThread ;
/**//// <summary>
/// 最小监听线程数
/// </summary>
protected int m_intMinThreadsCount ;
/**//// <summary>
/// 最大监听线程数
/// </summary>
protected int m_intMaxThreadsCount ;
/**//// <summary>
/// 编码方式
/// </summary>
protected System.Text.Encoding m_objEncoding ;
#endregion
属性定义#region 属性定义
public string ServerName
{
get
{
return this.m_strServerName ;
}
set
{
this.m_strServerName = value ;
}
}//end property
/**//// <summary>
/// 存取端口的属性
/// </summary>
public int Port
{
get
{
return this.m_intPort ;
}
set
{
this.m_intPort = value ;
}
}//end property
/**//// <summary>
/// 存取最小工作线程数的属性
/// </summary>
/// <remarks>server开始时启动的线程数，必须在1-999之间</remarks>
public int MinThreadsCount
{
get
{
return this.m_intMinThreadsCount ;
}
set
{
if(value > 0 && value < 1000)
{
this.m_intMinThreadsCount = value ;
}
}
}//end property
/**//// <summary>
/// 存取最大工作线程数的属性
/// </summary>
/// <remarks>server最大能启动的线程数，必须在1-999之间，并且不能小于MinThreadsCounts</remarks>
public int MaxThreadsCount
{
get
{
return this.m_intMaxThreadsCount ;
}
set
{
if(value > 0 && value < 1000)
{
this.m_intMaxThreadsCount = value ;
}
}
}//end property
/**//// <summary>
/// server默认编码方式
/// </summary>
public System.Text.Encoding Encoding
{
get
{
return this.m_objEncoding ;
}
set
{
this.m_objEncoding = value ;
}
}//end property
#endregion
构造函数#region 构造函数
/**//// <summary>
/// 构造函数
/// </summary>
public Server()
{
this.m_strServerName = "Bigelage General Server" ;
this.m_bCanExit = false ;
this.m_intPort = 0 ;
this.m_objWatchThread = new Thread(new ThreadStart(OnWatch)) ;
this.m_objEncoding = System.Text.Encoding.Default ;
this.m_intMaxThreadsCount = 10 ;
this.m_intMinThreadsCount = 1 ;
this.myEvent = new AutoResetEvent(false) ;
this.m_bIsInitOK = false ;
}//end method
/**//// <summary>
/// 重载构造函数
/// </summary>
/// <param name="a_strServerName">server名</param>
/// <param name="a_intPort">监听端口号</param>
public Server(string a_strServerName , int a_intPort)
{
this.m_strServerName = a_strServerName ;
this.m_bCanExit = false ;
this.m_intPort = a_intPort ;
this.m_objWatchThread = new Thread(new ThreadStart(OnWatch)) ;
this.m_objEncoding = System.Text.Encoding.Default ;
this.m_intMaxThreadsCount = 10 ;
this.m_intMinThreadsCount = 1 ;
this.myEvent = new AutoResetEvent(false) ;
this.m_bIsInitOK = false ;
}//end method
/**//// <summary>
/// 析构函数
/// </summary>
~Server()
{
try
{
if(this.m_objWatchThread.ThreadState == System.Threading.ThreadState.Running)
{
this.m_objWatchThread.Interrupt() ;
this.m_objWatchThread = null ;
}
this.m_objListener.Stop() ;
this.m_objListener = null ;
}
catch(Exception e)
{
#if DEBUG
Console.WriteLine("结束错误:{0}" , e.ToString()) ;
#endif//DEBUG
}
}
#endregion
私有函数#region 私有函数
/**//// <summary>
/// 守护线程工作函数
/// </summary>
private void OnWatch()
{
#if DEBUG
Console.WriteLine("watching thread now begin") ;
#endif//DEBUG
while(!this.m_bCanExit)
{
#if DEBUG
Console.WriteLine("now {0} threads is started , now {1} Thread is working"
, intThreadCount , intWorkThreadCount) ;
#endif//DEBUG
/**////如果所有线程都在工作，起一个空闲线程来监听
if(this.m_bIsInitOK)
{
if(intWorkThreadCount > 0
&& intWorkThreadCount >= intThreadCount
&& intThreadCount < this.m_intMaxThreadsCount)
{
ThreadPool.QueueUserWorkItem(new WaitCallback(StartListen) , this.myEvent) ;
}
}
else
{
#if DEBUG
Console.WriteLine("Server is initialize now ") ;
#endif//DEBUG
}
Thread.Sleep(WATCHING_INTERVAL) ;
}
}//end method
#endregion
保护函数#region 保护函数
protected void Initialize()
{
this.m_objWatchThread.Start() ;
this.m_objWatchThread.IsBackground = true ;
//this.m_objWatchThread.Join() ;
Console.Write("\r\n{0} is Initializing." , this.m_strServerName) ;
#if DEBUG
Debug.Assert(this.m_intPort != 0 , "未指定端口！") ;
#endif//DEBUG
//绑定监听端口
this.m_objListener = new TcpListener(this.m_intPort) ;
this.m_bIsInitOK = true ;
}//end method
/**//// <summary>
/// 监听线程工作函数
/// </summary>
/// <param name="state">AutoResetEvent对象</param>
protected void StartListen(object state)
{
#if DEBUG
Console.WriteLine("thread{0} is waiting" , Thread.CurrentThread.GetHashCode()) ;
#endif//DEBUG
//线程计数加一
Interlocked.Increment(ref intThreadCount) ;
try
{
while(!this.m_bCanExit)
{
//等待接收一个新连接
Socket mySocket = this.m_objListener.AcceptSocket() ;
#if DEBUG
Console.WriteLine("thread {0} begin working" , Thread.CurrentThread.GetHashCode()) ;
#endif//DEBUG
if(mySocket.Connected)
{
//工作线程计数加一
Interlocked.Increment(ref intWorkThreadCount) ;
//同客户端交互
DoCommunication(mySocket) ;
//完毕后工作线程计数减一
Interlocked.Decrement(ref intWorkThreadCount) ;
mySocket.Close() ;
#if DEBUG
Console.WriteLine("thread {0} finished work" , Thread.CurrentThread.GetHashCode()) ;
#endif//DEBUG
if(intWorkThreadCount < intThreadCount - 1
&& intThreadCount > this.m_intMinThreadsCount)
{
#if DEBUG
Console.WriteLine("Too many not working thread , thread {0} will exit."
, Thread.CurrentThread.GetHashCode()) ;
#endif//DEBUG
Interlocked.Decrement(ref intThreadCount) ;
return ;
}
}
}//end while
}
catch(SocketException se)
{
#if DEBUG
Console.WriteLine("出现网络错误，工作线程关闭。错误{0}" , se.ToString()) ;
#endif//DEBUG
Interlocked.Decrement(ref intThreadCount) ;
Interlocked.Decrement(ref intWorkThreadCount) ;
}
catch(Exception e)
{
#if DEBUG
Console.WriteLine("出现错误：{0}" , e.Message) ;
#endif//DEBUG
Interlocked.Decrement(ref intThreadCount) ;
}
// if(intWorkThreadCount == 0)
// {
// ((AutoResetEvent)state).Set() ;
// }
}//end method
/**//// <summary>
/// 抽象方法，同客户端通讯
/// </summary>
/// <param name="a_objSocket">当前套接字</param>
protected abstract void DoCommunication(Socket a_objSocket) ;
#endregion
公共方法#region 公共方法
/**//// <summary>
/// 运行
/// </summary>
public void Run()
{
Initialize() ;
Console.WriteLine("{0} is running" , this.m_strServerName) ;
try
{
//开始监听端口
this.m_objListener.Start() ;
//起最小工作线程数量的端口监听线程
for(int i = 0 ; i < this.m_intMinThreadsCount ; i ++)
{
ThreadPool.QueueUserWorkItem(new WaitCallback(StartListen) , myEvent) ;
}
myEvent.WaitOne() ;
#if DEBUG
Console.WriteLine("all thread exit") ;
#endif
}
catch (SocketException socketError)
{
if (socketError.ErrorCode == 10048)
{
Console.WriteLine("Connection to this port failed. "
+ " There is another server is listening on this port.");
}
else
{
Console.WriteLine("A Socket error occours:{0}" ,socketError.Message) ;
}
}
catch(Exception e)
{
Console.WriteLine("An error occours:{0}" , e.Message) ;
}
}//end method
public void Stop()
{
Console.WriteLine("{0} try to stop . " , this.m_strServerName) ;
//发出退出信号
this.m_bCanExit = true ;
//等待所有工作的线程结束任务，500毫秒检查一次
while(intWorkThreadCount != 0)
{
Thread.Sleep(500) ;
}
//发出线程结束信号，通知主程序可以退出
this.myEvent.Set() ;
}
#endregion
}//end class
}//end namespace /Files/lovebanyi/threadpool.rar
原文地址：https://www.cnblogs.com/lovebanyi/p/307467.html