线程池

线程池的概念

 

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

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

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

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

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

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

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

http://www.cnblogs.com/hnxxcxg/archive/2012/09/03/2668462.html

 

// 单元功用: 线程池
// 单元设计: 陈新光
// 设计日期: 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.

http://www.cnblogs.com/hnxxcxg/archive/2012/09/03/2669717.html