单位时间内必须处理数目巨大的连接请求，但处理时间却相对较短。

传统多线程方案中，一旦接受到请求之后，即创建一个新的线程，由该线程执行任务。任务执行完毕后，线程退出。这就是即时创建，即时销毁的策略。尽管与创建进程相比，创建线程的时间已经大大的缩短，但是如果提交给线程的任务执行时间很短，而且执行次数极其频繁，那么服务器将处于不停的创建线程，销毁线程的状态。

t1: 线程创建时间
t2: 线程执行时间，包括线程的同步等时间
t3: 线程销毁时间

线程本身的开销所占的比例为(t1+t3)/(t1+t2+t3)。如果线程执行的时间很短，这笔开销可能占到20%~50%左右。如果任务执行很频繁的话，这笔开销将是不可忽略的。

线程池能够减少创建的线程个数。通常线程池所允许的并发线程是有上限的，如果同时需要并发的线程数超过上限，那么一部分线程将会等待。而传统方案中，如果同时请求数目为2000，那么最坏情况下，系统可能需要产生2000个线程。尽管这不是一个很大的数目，但是也有部分机器可能达不到这种要求。

线程池的出现正是着眼于减少线程本身带来的开销。线程池采用预创建的技术，在应用程序启动之后，立即创建一定数目的线程，放入空闲队列中。这些线程都是处于阻塞（挂起）状态，不消耗CPU，只占用较小的内存空间。当任务到来后，缓冲池选择一个空闲线程，把任务传入此线程中运行。当线程池中的线程都在处理任务，线程池自动创建一定数量的新线程，用于处理更多的任务。在任务执行完毕后线程也不退出，而是继续保持在线程池中等待下一次的任务。当系统比较空闲时，大部分线程都一直处于暂停状态，线程池自动销毁一部分线程，回收系统资源。

线程池管理器：用于创建并管理线程池
工作线程：线程池中实际执行的线程
任务接口：将线程执行的任务抽象出来，形成任务接口，使线程池与具体的任务无关
任务队列：可能是队列，链表之类的数据结构，其中保存执行线程

Event事件用法与Mutex差不多，但它可以使用：SetEvent（启动运行）ResetEvent（暂停运行）、PulseEvent（执行一次后立即暂停）。

先看一下创建函数：CreateEvent(
lpEventAttributes: PSecurityAttributes;
bManualReset: BOOL;
bInitialState: BOOL;
lpName: PWideChar ): THandle; stdcall;

（lpEventAttributes参数，指向TSecurityAttributes记录的指针，一般可以缺省填入nil值；

bManualReset参数，是否可手动暂停，True为可手动，False为事件对象控制一次后将立即暂停；

bInitialState参数，初始状态，True为事件对象创建后处可运行状态，False为暂停状态；

lpName参数，事件的名称；

返回值为句柄。）

FEvent := CreateEvent(nil, True, False, nil);

PulseEvent(FEvent);

if WaitForSingleObject(FEvent, INFINITE) = WAIT_OBJECT_0 then

CloseHandle(FEvent);

// 单元功用: 线程池
// 单元设计: 陈新光
// 设计日期: 2012-09-03

unit ThreadPool;

interface

uses
system.Classes, system.SyncObjs, system.SysUtils,
system.DateUtils, GlobalVar, Vcl.Forms, Winapi.Windows;

type
TWorkThread = class(TThread)
private
FThreadMethod: TThreadMethod;
Fsync: Boolean;
FEvent: THandle;
protected
procedure Execute; override;
public
constructor Create; overload;
destructor Destroy; override;
property Sync: Boolean read Fsync write Fsync;
property ThreadMethod: TThreadMethod read FThreadMethod write FThreadMethod;
procedure Run;
end;

PServerObject = ^TServerObject;

TServerObject = record
ServerObject: TWorkThread;
InUse: Boolean;
end;

TThreadPool = class
private
FCriticalSection: TCriticalSection;
FServerObjects: TList;
FPoolSize: integer;

public
constructor Create; overload;
destructor Destroy; override;
function Lock: TWorkThread;
procedure Unlock(Value: TWorkThread);
procedure Init;
property PoolSize: integer read FPoolSize write FPoolSize;
end;

var
G_ThreadPool: TThreadPool;

implementation

uses CommonFunction;

constructor TThreadPool.Create;
begin
FPoolSize := G_ThreadPoolSize;
FServerObjects := TList.Create;
FCriticalSection := TCriticalSection.Create;
end;

destructor TThreadPool.Destroy;
begin
while FServerObjects.Count > 0 do
begin
Dispose(PServerObject(FServerObjects[0]));
FServerObjects.Delete(0);
end;
FreeAndNil(FServerObjects);
FreeAndNil(FCriticalSection);
inherited Destroy;
end;

procedure TThreadPool.Init;
var
i: integer;
p: PServerObject;
begin
if not Assigned(FServerObjects) then
exit;
for i := 1 to FPoolSize do
begin
New(p);
if Assigned(p) then
begin
p^.ServerObject := TWorkThread.Create;
p^.InUse := False;
FServerObjects.Add(p);
end;
end;
end;

function TThreadPool.Lock: TWorkThread;
var
i: integer;
begin
Result := nil;
try
FCriticalSection.Enter;
try
for i := 0 to FServerObjects.Count - 1 do
begin
if (not PServerObject(FServerObjects[i])^.InUse) then
begin
PServerObject(FServerObjects[i])^.InUse := True;
Result := PServerObject(FServerObjects[i])^.ServerObject;
Break;
end;
end;
finally
FCriticalSection.Leave;
end;
except
on E: Exception do
begin
LogInfo('TThreadPool.Lock' + E.Message);
exit;
end;
end;
end;

procedure TThreadPool.Unlock(Value: TWorkThread);
var
i: integer;
begin
if not Assigned(Value) then
exit;
try
FCriticalSection.Enter;
try
for i := 0 to FServerObjects.Count - 1 do
begin
if Value = PServerObject(FServerObjects[i])^.ServerObject then
begin
PServerObject(FServerObjects[i])^.InUse := False;
// Value.Suspended := True;
Value.ThreadMethod := nil;
Break;
end;
end;
finally
FCriticalSection.Leave;
end;
except
on E: Exception do
begin
LogInfo('TThreadPool.Unlock' + E.Message);
exit;
end;
end;
end;

{ TWorkThread }

constructor TWorkThread.Create;
begin
FEvent := CreateEvent(nil, True, False, nil);
Create(True);
FreeOnTerminate := True;
end;

destructor TWorkThread.Destroy;
begin
CloseHandle(FEvent);
inherited;
end;

procedure TWorkThread.Execute;
begin
inherited;
while not Terminated do
if WaitForSingleObject(FEvent, INFINITE) = WAIT_OBJECT_0 then
if Assigned(FThreadMethod) then
if Fsync then
Synchronize(FThreadMethod)
else
FThreadMethod;
end;

procedure TWorkThread.Run;
begin
PulseEvent(FEvent);
end;

end.