delphi,IOCP之内存分配池[1]

最新推荐文章于 2023-03-16 14:56:38 发布
最新推荐文章于 2023-03-16 14:56:38 发布
阅读量1.7k 收藏
点赞数
分类专栏： delphi散记 文章标签： delphi function null constructor integer destructor
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Im17benteng/article/details/7167831
版权

不费话上代码

 

{******************************************************************************}
{ @UnitName     : uVirtualMemPool.pas                                          }
{ @Project      : QsIOCP                                                       }
{ @Copyright    : -                                                            }
{ @Author       : 奔腾的心(7180001)                                            }
{ @Description  : 分页式虚拟内存管理                                           }
{ @FileVersion  : 1.0.0.0                                                      }
{ @CreateDate   : 2011-07-16                                                   }
{ @Comment      : -                                                            }
{ @LastUpdate   : 2011-07-20                                                   }
{******************************************************************************}
unit uVirtualMemPool;

interface

uses
  SysUtils, Windows;

type
  TVirtualMemPool = class;

  PSBTNode = ^TSBTNode;
  TSBTNode = record
    IsUse:          Boolean;
    count:          Cardinal;
    value:          Pointer;
    data:           Cardinal;
    size:           Cardinal;
    lch,rch:        PSBTNode;
  end;

  // 平衡二叉查找树SBT
  TSizeBalancedTree = class
  private
    VMPool:         TVirtualMemPool;
    // 节点数
    NodeCount:      Cardinal;
    // 根节点,空节点
    root,null:      PSBTNode;
    // 左旋转
    procedure lrotate(var x: PSBTNode); inline;
    // 右旋转
    procedure rrotate(var x: PSBTNode); inline;
    // 保持性质
    procedure maintain(var t: PSBTNode; const flag: Boolean); inline;
    // 增加
    procedure TreeAdd(var t: PSBTNode; v: PSBTNode); inline;
    // 移除
    function TreeRemove(var t: PSBTNode; var n: PSBTNode; v: Cardinal): Cardinal; inline;
    // 返回第 x 大的元素
    function TreeSelect(var t: PSBTNode; k: Cardinal; var r: Cardinal): Cardinal; inline;
    // 查找
    function TreeFind(var t: PSBTNode; v: Cardinal): Boolean; inline;
    // 排名
    function TreeRank(var t: PSBTNode; v: Cardinal): Cardinal; inline;
    // 向前,大
    function TreeSucc(var t: PSBTNode; v: Cardinal): Cardinal; inline;
    // 向后,小
    function TreePred(var t: PSBTNode; v: Cardinal): Cardinal; inline;
  public
    constructor Create(AVMpool: TVirtualMemPool);
    destructor Destroy; override;
    procedure add(v: PSBTNode);
    function remove(v: Cardinal): PSBTNode;
    function select(k: Cardinal): Cardinal; inline;
    function find(v: Cardinal): Boolean; inline;
    function rank(v: Cardinal): Cardinal; inline;
    function succ(v: Cardinal): Cardinal; inline;
    function pred(v: Cardinal): Cardinal; inline;
  end;

  // 内存管理
  TVirtualMemPool = class
  private
    m_VMLock:         TRTLCriticalSection;
    m_NMLock:         TRTLCriticalSection;
    m_PageSize:       Cardinal;
    m_Count:          Cardinal;
    m_UseHeightCount: Cardinal;
    m_lpBase:         Pointer;
    m_Buckets:        array of PSBTNode;
    m_SBTStorage:     TSizeBalancedTree;
  private
    function GetCount: Cardinal;
    function GetUseCount: Cardinal;
    function GetFreeCount: Cardinal;
    function GetUseHeightCount: Cardinal;
    procedure InitMemPool(ACount: Integer);
    procedure Clear;
  public
    property Count: Cardinal read GetCount;
    property UseCount: Cardinal read GetUseCount;
    property FreeCount: Cardinal read GetFreeCount;
    property UseHeightCount: Cardinal read GetUseHeightCount;
  public
    constructor Create(ACount: Integer);
    destructor Destroy; override;
  public
    function VMAlloc(dwSize: Cardinal; IsLock: Boolean = True): Pointer;
    function VMReAlloc(var P; dwSize: Cardinal): Pointer;
    function VMFree(var P; IsLock: Boolean = True): Boolean;
  end;

implementation

{ TSizeBalancedTree }
constructor TSizeBalancedTree.Create(AVMpool: TVirtualMemPool);
begin
  VMPool := AVMpool;
  NodeCount := 0;
  new(null);
  null^.data := Cardinal(-1);
  null^.size := 0;
  null^.lch := null;
  null^.rch := null;
  root := null;
end;

destructor TSizeBalancedTree.Destroy;
begin
  NodeCount := 0;
  Dispose(null);
  inherited Destroy;
end;

procedure TSizeBalancedTree.lrotate(var x: PSBTNode);
var
  y: PSBTNode;
begin
  y := x^.rch;
  x^.rch := y^.lch;
  y^.lch := x;
  y^.size := x^.size;
  x^.size := x^.lch^.size+x^.rch^.size+1;
  x := y;
end;

procedure TSizeBalancedTree.rrotate(var x: PSBTNode);
var
  y: PSBTNode;
begin
  y := x^.lch;
  x^.lch := y^.rch;
  y^.rch := x;
  y^.size := x^.size;
  x^.size := x^.lch^.size+x^.rch^.size+1;
  x := y;
end;

procedure TSizeBalancedTree.maintain(var t: PSBTNode; const flag: Boolean);
begin
  if t=null then
    exit;
  if not flag then
    if t^.lch^.lch^.size>t^.rch^.size then
      rrotate(t)
    else if t^.lch^.rch^.size>t^.rch^.size then
    begin
      lrotate(t^.lch);
      rrotate(t);
    end
    else
      exit
  else if t^.rch^.rch^.size>t^.lch^.size then
    lrotate(t)
  else if t^.rch^.lch^.size>t^.lch^.size then
  begin
    rrotate(t^.rch);
    lrotate(t);
  end
  else
    exit;
  maintain(t^.lch, false);
  maintain(t^.rch, true);
  maintain(t, false);
  maintain(t, true);
end;

procedure TSizeBalancedTree.TreeAdd(var t: PSBTNode; v: PSBTNode);
begin
  if v^.IsUse=False then
    Exit;
  if t=null then
  begin
    t := v;
    //进入的内存设置为未使用
    t^.IsUse := False;
    t^.count := 0;
    t^.size := 1;
    t^.lch := null;
    t^.rch := null;
    Inc(NodeCount);
  end
  else begin
    inc(t^.size);
    if v^.data<t^.data then
      TreeAdd(t^.lch, v)
    else
      TreeAdd(t^.rch, v);
    maintain(t, v^.data>=t^.data);
  end;
end;

function TSizeBalancedTree.TreeRemove(var t: PSBTNode; var n: PSBTNode; v: Cardinal): Cardinal;
var
  tmp: PSBTNode;
begin
  //Result := Cardinal(-1);
  dec(t^.size);
  if(v=t^.data) or ((v<t^.data) and (t^.lch=null)) or ((v>t^.data) and (t^.rch=null)) then
  begin
    Result := t^.data;
    if(t^.lch=null) or (t^.rch=null) then
    begin
      if t^.lch=null then
      begin
        tmp := t;
        t := tmp^.rch;
        if tmp<>null then
        begin
          n := tmp;
          Dec(NodeCount);
          Exit;
        end;
      end;
      if t^.rch=null then
      begin
        tmp := t;
        t := tmp^.lch;
        if tmp<>null then
        begin
          n := tmp;
          Dec(NodeCount);
          Exit;
        end;
      end;
    end
    else
      t^.data := TreeRemove(t^.lch, n, t^.data+1);
  end
  else if v<t^.data then
    Result := TreeRemove(t^.lch, n, v)
  else
    Result := TreeRemove(t^.rch, n, v);
end;

function TSizeBalancedTree.TreeSelect(var t: PSBTNode; k: Cardinal; var r: Cardinal): Cardinal;
begin
  if t=null then
  begin
    Result := Cardinal(-1);
    Exit;
  end;
  Inc(r);
  if (k=t^.lch^.size+1) then
  begin
    Result := t^.data;
    exit;
  end;
  if k<=t^.lch^.size then
    Result := TreeSelect(t^.lch, k, r)
  else
    Result := TreeSelect(t^.rch, k-1-t^.lch^.size, r);
end;

function TSizeBalancedTree.TreeFind(var t: PSBTNode; v: Cardinal): Boolean;
begin
  if t=null then
  begin
    Result := false;
    exit;
  end;
  if v<t^.data then
    Result := TreeFind(t^.lch,v)
  else
    Result := (v=t^.data) or TreeFind(t^.rch,v);
end;

function TSizeBalancedTree.TreeRank(var t: PSBTNode; v: Cardinal): Cardinal;
begin
  if t=null then
  begin
    Result := 1;
    exit;
  end;
  if v<t^.data then
    Result := TreeRank(t^.lch,v)
  else
    Result := t^.lch^.size+1+TreeRank(t^.rch,v);
end;

function TSizeBalancedTree.TreeSucc(var t: PSBTNode; v: Cardinal): Cardinal;
var
  tmp:Cardinal;
begin
  if t=null then
  begin
    Result := v;
    exit;
  end;
  if v>=t^.data then
    Result := TreeSucc(t^.rch,v)
  else
  begin
    tmp:=TreeSucc(t^.lch,v);
    if tmp=v then
      tmp := t^.data;
    Result := tmp;
  end;
end;

function TSizeBalancedTree.TreePred(var t: PSBTNode; v: Cardinal): Cardinal;
var
  tmp: Cardinal;
begin
  if t=null then
  begin
    Result := v;
    exit;
  end;
  if v<=t^.data then
    Result := TreePred(t^.lch, v)
  else
  begin
    tmp := TreePred(t^.rch,v);
    if tmp=v then
      tmp := t^.data;
    Result := tmp;
  end;
end;

procedure TSizeBalancedTree.add(v: PSBTNode);
begin
  TreeAdd(root, v);
end;

function TSizeBalancedTree.remove(v: Cardinal): PSBTNode;
var
  v2: Cardinal;
  C: Pointer;
  P: PSBTNode;
begin
  Result := nil;
  TreeRemove(root, Result, v);
  if Result=nil then
    Exit;
  v2 := Result^.data;
  Result^.data := v;
  //移出的内存设置为使用
  Result^.IsUse := True;
  //value交换
  C := VMPool.m_Buckets[v2]^.value;
  VMPool.m_Buckets[v2]^.value := VMPool.m_Buckets[v]^.value;
  VMPool.m_Buckets[v]^.value := C;
  //位置交换
  P := VMPool.m_Buckets[v2];
  VMPool.m_Buckets[v2] := VMPool.m_Buckets[v];
  VMPool.m_Buckets[v] := P;
end;

function TSizeBalancedTree.select(k: Cardinal): Cardinal;
var
  R: Cardinal;
begin
  R := 0;
  if root=null then
  begin
    Result := Cardinal(-1);
    Exit;
  end;
  Result := TreeSelect(root, k, R);
end;

function TSizeBalancedTree.find(v: Cardinal): Boolean;
begin
  Result := TreeFind(root, v);
end;

function TSizeBalancedTree.rank(v: Cardinal): Cardinal;
begin
  Result := TreeRank(root, v);
end;

function TSizeBalancedTree.succ(v: Cardinal): Cardinal;
begin
  Result := TreeSucc(root, v);
end;

function TSizeBalancedTree.pred(v: Cardinal): Cardinal;
begin
  Result := TreePred(root, v);
end;

{ TVirtualMemPool }
constructor TVirtualMemPool.Create(ACount: Integer);
var
  SysInfo: TSystemInfo;
begin
  inherited Create;;
  InitializeCriticalSection(m_VMLock);
  InitializeCriticalSection(m_NMLock);
  GetSystemInfo(SysInfo);
  m_PageSize := SysInfo.dwPageSize;
  m_SBTStorage := TSizeBalancedTree.Create(Self);
  m_Count := ACount;
  m_UseHeightCount := 0;
  InitMemPool(m_Count);
end;

destructor TVirtualMemPool.Destroy;
begin
  FreeAndNil(m_SBTStorage);
  Clear;
  VirtualFree(m_lpBase, 0, MEM_RELEASE);
  DeleteCriticalSection(m_NMLock);
  DeleteCriticalSection(m_VMLock);
  inherited Destroy;
end;

function TVirtualMemPool.GetCount: Cardinal;
begin
  Result := m_Count;
end;

function TVirtualMemPool.GetUseCount: Cardinal;
begin
  EnterCriticalSection(m_NMLock);
  try
    Result := m_Count - m_SBTStorage.NodeCount;
  finally
    LeaveCriticalSection(m_NMLock);
  end;
end;

function TVirtualMemPool.GetFreeCount: Cardinal;
begin
  EnterCriticalSection(m_NMLock);
  try
    Result := m_SBTStorage.NodeCount;
  finally
    LeaveCriticalSection(m_NMLock);
  end;
end;

function TVirtualMemPool.GetUseHeightCount: Cardinal;
begin
  if m_UseHeightCount<GetUseCount then
    m_UseHeightCount := GetUseCount;
  Result := m_UseHeightCount;
end;

procedure TVirtualMemPool.InitMemPool(ACount: Integer);
var
  I: Integer;
begin
  EnterCriticalSection(m_VMLock);
  try
    // 申请大块内存
    m_lpBase := VirtualAlloc(nil,
    ACount*m_PageSize,
    MEM_RESERVE,
    PAGE_NOACCESS);
    SetLength(m_Buckets, ACount);
    //debug('m_lpBase: %d, NumberOfNode: %d', [Cardinal(m_lpBase), NumberOfNode]);
    for I := 0 to ACount-1 do
    begin
      { 为第I页地址提交内存。 }
      New(m_Buckets[I]);
      m_Buckets[I]^.IsUse := True;
      m_Buckets[I]^.data := I;
      m_Buckets[I]^.value := VirtualAlloc(Pointer(Cardinal(m_lpBase)+(I*m_PageSize)),
                             m_PageSize,
                             MEM_COMMIT,
                             PAGE_READWRITE);
      //debug('I: %d=%d', [I, Cardinal(m_Buckets[I]^.value)]);
      //ZeroMemory(m_Buckets[I]^.value, m_PageSize);
      m_SBTStorage.add(m_Buckets[I]);
    end;
  finally
    LeaveCriticalSection(m_VMLock);
  end;
end;

procedure TVirtualMemPool.Clear;
var
  I: Integer;
begin
  EnterCriticalSection(m_VMLock);
  try
    for I := 0 to Length(m_Buckets)-1 do
    begin
      Dispose(m_Buckets[I]);
    end;
  finally
    LeaveCriticalSection(m_VMLock);
  end;
end;

function TVirtualMemPool.VMAlloc(dwSize: Cardinal; IsLock: Boolean = True): Pointer;
var
  N, M, D1, D2, NStart, NEnd: Integer;
  P: PSBTNode;
begin
  if FreeCount<=0 then
  begin
    raise Exception.Create('No free pages in main memory.');
    Exit;
  end;
  if IsLock then EnterCriticalSection(m_VMLock);
  try
    N := dwSize div m_PageSize;
    if (dwSize mod m_PageSize)<>0 then
      Inc(N);
    M := 1;
    D2 := -1;
    D1 := m_SBTStorage.select(1);
    if D1<0 then
    begin
      Result := nil;
      Exit;
    end;
    if N<=1 then
    begin
      NStart := D1;
      //移出使用中的对像
      P := m_SBTStorage.remove(NStart);
      if P=nil then
      begin
        Result := nil;
        Exit;
      end;
      P^.count := 1;
      Result := P^.value;
      Exit;
    end;
    while True do
    begin
      //右旋转
      D2 := m_SBTStorage.succ(D1);
      if D2=D1 then
        Break;
      if D2=D1+1 then
      begin
        Inc(M);
      end
      else
      begin
        M := 1;
      end;
      if M>=N then
        Break;
      D1 := D2;
    end;
    NStart := D2 - N + 1;
    NEnd := NStart + N;
    P := m_SBTStorage.remove(NStart);
    P^.count := N;
    Result := P^.value;
    Inc(NStart);
    while NStart<NEnd do
    begin
      m_SBTStorage.remove(NStart);
      Inc(NStart);
    end;
  finally
    if IsLock then LeaveCriticalSection(m_VMLock);
  end;
end;

function TVirtualMemPool.VMReAlloc(var P; dwSize: Cardinal): Pointer;
var
  OldN, M, NewN, NEnd: Cardinal;
  NewP: Pointer;
begin
  Result := nil;
  if Pointer(P)=nil then
  begin
    Result := VMAlloc(dwSize);
    Exit;
  end;
  EnterCriticalSection(m_VMLock);
  try
    M := (Cardinal(Pointer(P))-Cardinal(m_lpBase)) div m_PageSize;
    // 原页数
    OldN := m_Buckets[M]^.count;
    // 新页数
    NewN := dwSize div m_PageSize;
    if (dwSize mod m_PageSize)<>0 then
      Inc(NewN);
    // 新页数=原页数
    if NewN=OldN then
    begin
      Result := Pointer(P);
    end
    // 新页数<原页数,多余的页放回页表
    else if NewN<OldN then
    begin
      NEnd := M + OldN;
      m_Buckets[M]^.count := OldN-NewN;
      M := M + NewN;
      while M<NEnd do
      begin
        m_SBTStorage.add(m_Buckets[M]);
        Inc(M);
      end;
      Result := Pointer(P);
    end
    // 新页数>原页数,重新申请并Copy原数据到新数据
    else if NewN>OldN then
    begin
      NewP := VMAlloc(dwSize, False);
      //原数据Copy到新数据中
      if NewP<>nil then
        CopyMemory(NewP, Pointer(P), OldN*m_PageSize);
      //放回原页数
      VMFree(P, False);
      //返回
      Pointer(P) := NewP;
      Result := NewP;
    end;
  finally
    LeaveCriticalSection(m_VMLock);
  end;
end;

function TVirtualMemPool.VMFree(var P; IsLock: Boolean = True): Boolean;
var
  M, N, NEnd: Cardinal;
begin
  if Pointer(P)=nil then
    Exit;
  if IsLock then EnterCriticalSection(m_VMLock);
  try
    M := (Cardinal(Pointer(P))-Cardinal(m_lpBase)) div m_PageSize;
    Pointer(P) := nil;
    // 页数
    N := m_Buckets[M]^.count;
    NEnd := M + N;
    // 放回
    while M<NEnd do
    begin
      m_SBTStorage.add(m_Buckets[M]);
      Inc(M);
    end;
  finally
    if IsLock then LeaveCriticalSection(m_VMLock);
  end;
  Result := True;
end;

end.

用法

var

 VMM: TVirtualMemPool;

 p: Pointer;

begin

  VMM := TVirtualMemPool.Create(100000);

  //申请内存

  p := VMM.VMAlloc(1024);

  //重新申请大小

  p := VMM.VMReAlloc(1024);

  //释放内存

  VMM.VMFree(p);

  VMM.Free;

end;

 

 

具体代码大家可以慢慢看，另请高手看到后不要取笑，希望高手能优化一份并共享出来！

代码里使用的方法基本与linux内存管理原理差不多！可能也与windows内存管理大同小异吧！

不对之处请高手指正

Im17benteng
关注
专栏目录
IOCP的内存管理
xuwei2007的专栏
08-29 2324
IOCP内存管理换上了log4cplus日志系统，记录发现有些情况下的io和完成key没有回归队列，多处释放又怕导致重复入队列。先转贴两篇网上的文章：IOCP中的socket错误和资源释放处理方法前言:   错误处理和socket释放, 是IOCP编程中的一大难点. 本文试图就IOCP设计中经常遇到的这个难题展开论述并寻找其解决方案, 事实上, 文中所述的解决方式不仅仅适用于IOCP,
delphi,IOCP之高效线程池[2]
Im17benteng的专栏
12-31 1784
{******************************************************************************} { @UnitName     : uQsThreadPool.pas                                            } { @Project      : QsIOCP 1.0
内存池的实现
重剑无锋 大巧不工
01-08 744
内存池的实现 引言 C/C++下内存管理是让几乎每一个程序员头疼的问题，分配足够的内存、追踪内存的分配、在不需要的时候释放内存——这个任务相当复杂。而直接使用系统调用malloc/free、new/delete进行内存分配和释放，有以下弊端： 调用malloc/new,系统需要根据“最先匹配”、“最优匹配”或其他算法在内存空闲块表中查找一块空闲内存，调用free/delete
简单的delphi内存池
10-10
简单的delphi内存池，怎样做到工业级？？
Delphi-IOCP 学习笔记<六>=====IO内存池和扩展套接字(ClientContext)
04-22 265
规划下将要出炉的IOCP。 1.将接收IO数据改成内存池。 2.扩展lpCompletionKey: DWORD参数.扩展套接字对象。 3.借鉴java netty思路，使用decode –> handler的思路来处理客户端数据。 //内存池 unit uMemPool; interface uses JwaWinsock2, Wind...
delphi原子操作实现简单内存池
最新发布
hksoobe的专栏
03-16 244
【代码】delphi原子操作实现简单内存池。
IOCP 内存池线程池的一个例子
04-06
在频繁分配和释放小块内存的情况下，内存池可以避免频繁的系统调用，减少内存碎片，并提高内存分配和回收的速度。 结合这两个概念，"IOCP 内存池线程池"意味着在一个基于IOCP的系统中，线程池中的工作线程使用了...
Delphi版IOCP加框DBIOCP2.4
08-19
5. **内存管理**：高效的内存管理是高性能网络编程的关键，DBIOCP可能包含优化的内存分配和释放策略，减少内存碎片和提高效率。 6. **性能监控**：可能包括性能统计和监控功能，帮助开发者分析和优化程序性能。 综...
delphi稳定高效iocp例子
09-01
1. 错误处理：确保所有可能的错误都得到了适当的处理，例如网络中断、内存分配失败等。 2. 资源管理：正确关闭和释放I/O句柄、线程和其他资源，避免内存泄漏和资源耗尽。 3. 并发控制：合理设计线程池大小，避免过多...
Windows高性能大并发IOCP
08-27
1. **IOCP基础** - **异步I/O模型**：IOCP利用系统内核调度，将I/O操作与用户进程解耦，使得在等待I/O操作完成时，CPU可以执行其他任务，提高了系统效率。 - **完成端口**：IOCP作为一个多线程调度中心，负责接收...
德国人编写的delphi专用线程池
10-14
德国人编写的delphi专用线程池，代码相当专业，需要有一定的功力，里面包括1.06和1.09两个版本，花了好长时间才找到最新1.09版的，很不错的代码，强烈推荐。 国内好多求质数的线程池均是参考这个写的。
MemoryPool--内存池类
05-18
MemoryPool源代码包括（内存池管理类和demo，测试其效率性能）。
delphi数据连接池
05-11
支持delphi的数据连接池，支持旧版本，非常好用，很稳定。
一个简单的内存池一个简单的内存池
08-12
一个简单的内存池一个简单的内存池一个简单的内存池一个简单的内存池一个简单的内存池
Delphi IOCP演示源代码及DEMO
05-11
共享一个基于Delphi环境下的IOCP源代码，附上的一个例子，主要参考网上的资料做的一个例子。common 目录为 IOCP的代码，根目录下的是Demo代码. 　　测试及运行方法：直接运行 test.exe 然后开启服务，运行 custom.bat 执行ab -n 100000 -c 1000 -k 127.0.0.1:9999/ 运行环境：Windows/Delphi7
DELPHI中完成端口(IOCP)的简单分析（1）
11-03 965
用DELPHI开发网络代码已经有一段时间了！我发现在网上用VC来实现完成端口（IOCP）的代码很多，但是使用DELPHI来实现的就比较少了。对IOCP讲的清楚的就更少了。在这里我把自己编写DELPHI下的IOCP写出来，希望对刚学完成端口的朋友有个帮助。首先我们来了解一些在使用IOCP的时候需要使用的一些结构！（1）：单IO数据结构  LPVOID = Pointer;  LPPE
IOCP线程池的开发-(1)
weixin_34013044的博客
07-24 203
在以前的文章中，我已经描述了使用IOCP来编写一个可以支持大量数据连接的网络通信部分的内容。但是IOCP的作用仅限于用来编写网络通信吗？答案是否定的。在《windows核心编程》一书中，作者也说明了“使用IO完成端口允许我们向一个设备同时发送多个IO请求，它允许一个线程发出IO请求，另一个线程对结果进行处理，这项技术具有高度的伸缩性和最佳的灵活性”（windows核心编程第297页）。这就说明了I...
IOCP线程池的开发-(2)
weixin_34092455的博客
01-21 166
下来我们看一下如何使用Delphi编写一个IOCP的线程池。 创建一个IOCP线程池，至少需要2个基本类。首先：我们定义一个管理工作线程的线程池类（TTheadPool），这个类用来将接收到的数据转发给相应的工作线程类，同时将工作线程类返回的数据进行排队处理。其次：我们定义真正处理数据的工作线程类，此类用来对线程池类发来的数据进行相应的处理，同时将处理返回的数据通过线程池类返回。 现在我们分别...
内存池实现
wuleibilly3的专栏
09-17 453
/* * C内存池实现代码 * 作者:WDL * 出处:http://blog.csdn.net/wuleibilly3 * 转载请注明本博客 */ //内存池 typedef struct _MemTable MemTable; typedef struct _MemPool MemPool; typedef struct _MemNode MemNode; typedef struct _CheckAvail CheckAvail; #define MIN_M
Delphi IOCP代码实现及演示示例
开发者通过研究这部分代码，可以掌握如何在Delphi环境下创建IOCP实例，以及如何将Socket连接与之关联，从而实现对网络事件的高效处理。 而压缩包中的根目录下的代码则是实际的Demo程序代码，演示了如何使用"common...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值