论坛首页 › 电脑综合 › DELPHI环境下UDPSOCKET的使用？

eworker 发表于 2010-3-16 15:18:26

DELPHI环境下UDPSOCKET的使用？

用DELPHI的UDPSOCKET，定时去读取设备的数据，可否用非阻塞方式？

eworker 发表于 2010-3-16 15:39:40

unit   udp;   
   
interface   
   
uses   
      Windows,   Messages,   SysUtils,   Classes,   Graphics,   Controls,   Forms,   Dialogs,   winsock,   
      StdCtrls;   
   
const   
      WM_SOCK   =   WM_USER   +   1;         //自定义windows消息   
      UDPPORT   =   6767;                         //设定UDP端口号   
   
type   
      Tfrmmain   =   class(TForm)   
          Button1:   TButton;   
          Edit1:   TEdit;   
          Memo1:   TMemo;   
          Edit2:   TEdit;   
          Label1:   TLabel;   
          Label2:   TLabel;   
          procedure   FormCreate(Sender:   TObject);   
          procedure   FormClose(Sender:   TObject;   var   Action:   TCloseAction);   
          procedure   Button1Click(Sender:   TObject);   
      private   
          {   Private   declarations   }   
          s:   TSocket;   
          addr:   TSockAddr;   
          FSockAddrIn   :   TSockAddrIn;   
                  //利用消息实时获知UDP消息   
          procedure   ReadData(var   Message:   TMessage);   
                        message   WM_SOCK;   
      public   
          {   Public   declarations   }   
          procedure   SendData(Content:   String);   
      end;   
   
var   
      frmmain:   Tfrmmain;   
   
implementation   
   
{$R   *.DFM}   
   
procedure   Tfrmmain.FormCreate(Sender:   TObject);   
var   
      TempWSAData:   TWSAData;   
      //optval:   integer;   
begin   
//   初始化SOCKET   
            if   WSAStartup($101,   TempWSAData)=1   then   
                  showmessage('StartUp   Error!');   
   
            s   :=   Socket(AF_INET,   SOCK_DGRAM,   0);   
            if   (s   =   INVALID_SOCKET)   then       //Socket创建失败   
            begin   
                      showmessage(inttostr(WSAGetLastError())+'   Socket创建失败');   
                      CloseSocket(s);   
//                     exit;   
            end;   
            //发送方SockAddr绑定   
            addr.sin_family   :=   AF_INET;   
            addr.sin_addr.S_addr   :=   INADDR_ANY;   
            addr.sin_port   :=   htons(UDPPORT);   
            if   Bind(s,   addr,   sizeof(addr))   <>   0   then   
                begin   
                  showmessage('bind   fail');   
                end;   
            {optval:=   1;   
            if   setsockopt(s,SOL_SOCKET,SO_BROADCAST,pchar(@optval),sizeof(optval))   =   SOCKET_ERROR   then   
            begin   
                showmessage('无法进行UDP广播');   
            end;}   
            WSAAsyncSelect(s,   frmmain.Handle   ,   WM_SOCK,   FD_READ);   
            //接收端SockAddrIn设定   
            FSockAddrIn.SIn_Family   :=   AF_INET;   
            FSockAddrIn.SIn_Port   :=   htons(UDPPORT);   
end;   
   
procedure   Tfrmmain.FormClose(Sender:   TObject;   var   Action:   TCloseAction);   
begin   
          CloseSocket(s);   
end;   
   
procedure   Tfrmmain.ReadData(var   Message:   TMessage);   
var   
      buffer:   Array      of   char;   
      len:   integer;   
      flen:   integer;   
      Event:   word;   
      value:   string;   
begin   
            flen:=sizeof(FSockAddrIn);   
            FSockAddrIn.SIn_Port   :=   htons(UDPPORT);   
            Event   :=   WSAGetSelectEvent(Message.LParam);   
            if   Event   =   FD_READ   then   
            begin   
                      len   :=   recvfrom(s,   buffer,   sizeof(buffer),   0,   FSockAddrIn,   flen);   
                      value   :=   copy(buffer,   1,   len);   
                      Memo1.Lines.add(value)   
            end;   
end;   
   
procedure   Tfrmmain.SendData(Content:   String);   
var   
      value{,hostname}:   string;   
      len:   integer;   
begin   
   
            FSockAddrIn.SIn_Addr.S_addr   :=   inet_addr(pchar(Edit1.text));   //目的IP地址   
            value   :=   Content;   
            len   :=   sendto(s,   value,   Length(value),   0,   FSockAddrIn,   sizeof(FSockAddrIn));   
            if   (WSAGetLastError()   <>   WSAEWOULDBLOCK)   and   (WSAGetLastError()   <>   0)   then   
                  showmessage(inttostr(WSAGetLastError()));   
            if   len   =   SOCKET_ERROR   then   
                  showmessage('send   fail');   
            if   len   <>   Length(value)   then   
                  showmessage('Not   Send   all');   
end;   
   
procedure   Tfrmmain.Button1Click(Sender:   TObject);   
begin   
            senddata(Edit2.text);   
end;   
   
end.


{******************************************************************************}
{                     CnPack For Delphi/C++Builder                           }
{                     中国人自己的开放源码第三方开发包                         }
{                   (C)Copyright 2001-2007 CnPack 开发组                     }
{                   ------------------------------------                     }
{                                                                              }
{            本开发包是开源的自由软件，您可以遵照 CnPack 的发布协议来修      }
{      改和重新发布这一程序。                                                }
{                                                                              }
{            发布这一开发包的目的是希望它有用，但没有任何担保。甚至没有      }
{      适合特定目的而隐含的担保。更详细的情况请参阅 CnPack 发布协议。      }
{                                                                              }
{            您应该已经和开发包一起收到一份 CnPack 发布协议的副本。如果      }
{      还没有，可访问我们的网站：                                          }
{                                                                              }
{            网站地址：http://www.cnpack.org                                 }
{            电子邮件：master@cnpack.org                                       }
{                                                                              }
{******************************************************************************}

unit CnUDP;
{* |
================================================================================
* 软件名称：网络通讯组件包
* 单元名称：UDP 通讯单元
* 单元作者：周劲羽 (zjy@cnpack.org)
* 备    注：定义了 TCnUDP，使用非阻塞方式进行 UDP 通讯，支持广播
* 开发平台：PWin2000Pro + Delphi 5.01
* 兼容测试：PWin9X/2000/XP + Delphi 5/6/7 + C++Builder 5/6
* 本 地 化：该单元中的字符串均符合本地化处理方式
* 单元标识：$Id: CnUDP.pas,v 1.5 2007/01/08 09:19:59 liuxiao Exp $
* 修改记录：2003.11.21 V1.0
*                创建单元
================================================================================
|}

interface

{$I CnPack.inc}

uses
Windows, Messages, Classes, SysUtils, WinSock, Forms, contnrs;

type

//==============================================================================
// UDP 通讯类
//==============================================================================

{ TCnUDP }

TOnReceive = procedure(Sender: TComponent; Buffer: Pointer; Len: Integer;
    FromIP: string; Port: Integer) of object;
{* 接收到数据事件
   |
   Sender   - TCnUDP 对象
   Buffer   - 数据缓冲区
   Len      - 数据缓冲区长度
   FromIP   - 数据来源 IP
   Port       - 数据来源端口号
   |}

TCnUDP = class(TComponent)
{* 使用非阻塞方式进行 UDP 通讯的类。支持广播、数据队列等。}
private
    FRemoteHost: string;
    FRemotePort: Integer;
    FLocalPort: Integer;
    FSocketWindow: HWND;
    FOnDataReceived: TOnReceive;
    FListening: Boolean;
    Wait_Flag: Boolean;
    RemoteAddress, RemoteAddress2: TSockAddr;
    RemoteHostS: PHostEnt;
    Succeed: Boolean;
    Procing: Boolean;
    MyWSAData: TWSAData;
    EventHandle: THandle;
    ThisSocket: TSocket;
    Queue: TQueue;
    FLastError: Integer;
    procedure WndProc(var Message: TMessage);
    function ResolveRemoteHost(ARemoteHost: string): Boolean;
    procedure SetLocalPort(NewLocalPort: Integer);
    procedure ProcessIncomingdata;
    procedure ProcessQueue;
    procedure FreeQueueItem(P: Pointer);
    function GetQueueCount: Integer;
    procedure SetupLastError;
    function GetLocalHost: string;
    procedure UpdateBinding;
protected
    procedure Wait;
    procedure Loaded; override;
public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
   
    function SendStream(DataStream: TStream; BroadCast: Boolean = False): Boolean;
    {* 发送一个数据流。如果 BroadCase 为真，执行 UDP 广播，否则发送数据到
       RomoteHost 的机器上的 RemotePort 端口}
    function SendBuffer(Buff: Pointer; Length: Integer; BroadCast:
      Boolean = False): Boolean;
    {* 发送一个数据块。如果 BroadCase 为真，执行 UDP 广播，否则发送数据到
       RomoteHost 的机器上的 RemotePort 端口}
    procedure ClearQueue;
    {* 清空数据队列。如果用户来不及处理接收到的数据，组件会把新数据包放到数据
       队列中，调用该方法可清空数据队列}
   
    property LastError: Integer read FLastError;
    {* 最后一次错误的错误号，只读属性}
    property Listening: Boolean read FListening;
    {* 表示当前是否正在监听本地端口，只读属性}
    property QueueCount: Integer read GetQueueCount;
    {* 当前数据队列的长度，只读属性}
published
    property RemoteHost: string read FRemoteHost write FRemoteHost;
    {* 要发送 UDP 数据的目标主机地址}
    property RemotePort: Integer read FRemotePort write FRemotePort;
    {* 要发送 UDP 数据的目标主机端口号}
    property LocalHost: string read GetLocalHost;
    {* 返回本机 IP 地址，只读属性}
    property LocalPort: Integer read FLocalPort write SetLocalPort;
    {* 本地监听的端口号}
    property OnDataReceived: TOnReceive read FOnDataReceived write
      FOnDataReceived;
    {* 接收到 UDP 数据包事件}
end;

implementation

{$R-}

//==============================================================================
// 辅助过程
//==============================================================================

// 从Winsock 2.0导入函数WSAIOCtl
function WSAIoctl(s: TSocket; cmd: DWORD; lpInBuffer: PCHAR; dwInBufferLen:
DWORD;
lpOutBuffer: PCHAR; dwOutBufferLen: DWORD;
lpdwOutBytesReturned: LPDWORD;
lpOverLapped: POINTER;
lpOverLappedRoutine: POINTER): Integer; stdcall; external 'WS2_32.DLL';

const
SIO_GET_INTERFACE_LIST = $4004747F;
IFF_UP = $00000001;
IFF_BROADCAST = $00000002;
IFF_LOOPBACK = $00000004;
IFF_POINTTOPOINT = $00000008;
IFF_MULTICAST = $00000010;

type
sockaddr_gen = packed record
    AddressIn: sockaddr_in;
    filler: packed array of char;
end;

INTERFACE_INFO = packed record
    iiFlags: u_long;                  // Interface flags
    iiAddress: sockaddr_gen;            // Interface address
    iiBroadcastAddress: sockaddr_gen;   // Broadcast address
    iiNetmask: sockaddr_gen;            // Network mask
end;

// 取广播地址
procedure GetBroadCastAddress(sInt: TStrings);
var
s: TSocket;
wsaD: WSADATA;
NumInterfaces: Integer;
BytesReturned, SetFlags: u_long;
pAddr, pMask, pCast: TInAddr;
pAddrStr: string;
PtrA: pointer;
Buffer: array of INTERFACE_INFO;
i: Integer;
begin
WSAStartup($0101, wsaD);            // Start WinSock
s := Socket(AF_INET, SOCK_STREAM, 0); // Open a socket
if (s = INVALID_SOCKET) then
    exit;

try                                 // Call WSAIoCtl
    PtrA := @bytesReturned;
    if (WSAIoCtl(s, SIO_GET_INTERFACE_LIST, nil, 0, @Buffer, 1024, PtrA, nil,
      nil) <> SOCKET_ERROR) then
    begin                               // If ok, find out how
      // many interfaces exist
      NumInterfaces := BytesReturned div SizeOf(INTERFACE_INFO);
      sInt.Clear;
      for i := 0 to NumInterfaces - 1 do // For every interface
      begin
      SetFlags := Buffer.iiFlags;
      if (SetFlags and IFF_BROADCAST = IFF_BROADCAST) and not
          (SetFlags and IFF_LOOPBACK = IFF_LOOPBACK) then
      begin
          pAddr := Buffer.iiAddress.AddressIn.sin_addr;
          pMask := Buffer.iiNetmask.AddressIn.sin_addr;
          pCast.S_addr := pAddr.S_addr or not pMask.S_addr;
          pAddrStr := inet_ntoa(pCast);
          if sInt.IndexOf(pAddrStr) < 0 then
            sInt.Add(pAddrStr);
      end;
      end;
    end;
except
    ;
end;
CloseSocket(s);
WSACleanUp;
end;

//==============================================================================
// UDP 通讯类
//==============================================================================

{ TCnUDP }

const
WM_ASYNCHRONOUSPROCESS = WM_USER + 101;
Const_cmd_true = 'TRUE';

type
PRecvDataRec = ^TRecvDataRec;
TRecvDataRec = record
    FromIP: string;
    FromPort: u_short;
    Buff: Pointer;
    BuffSize: Integer;
end;

constructor TCnUDP.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
Queue := TQueue.Create;
FListening := False;
Procing := False;
GetMem(RemoteHostS, MAXGETHOSTSTRUCT);
FSocketWindow := AllocateHWND(WndProc);
EventHandle := CreateEvent(nil, True, False, '');
if WSAStartup($0101, MyWSADATA) = 0 then
begin
    ThisSocket := Socket(AF_INET, SOCK_DGRAM, 0);
    if ThisSocket = TSocket(INVALID_SOCKET) then
    begin
      SetupLastError;
      WSACleanup;
      Exit;
    end;
    setsockopt(ThisSocket, SOL_SOCKET, SO_DONTLINGER, Const_cmd_true, 4);
    FListening := True;
end;
end;

destructor TCnUDP.Destroy;
begin
ClearQueue;
Queue.Free;
FreeMem(RemoteHostS, MAXGETHOSTSTRUCT);
DeallocateHWND(FSocketWindow);
CloseHandle(EventHandle);
if FListening then
    WSACleanup;
inherited Destroy;
end;

procedure TCnUDP.UpdateBinding;
begin
if not (csDesigning in ComponentState) then
begin
    FListening := False;
    RemoteAddress2.sin_addr.S_addr := Inet_Addr('0.0.0.0');
    RemoteAddress2.sin_family := AF_INET;
    RemoteAddress2.sin_port := htons(FLocalPort);
    Wait_Flag := False;
    if WinSock.Bind(ThisSocket, RemoteAddress2, SizeOf(RemoteAddress2)) =
      SOCKET_ERROR then
    begin
      SetupLastError;
      WSACleanup;
      Exit;
    end;
    WSAAsyncSelect(ThisSocket, FSocketWindow, WM_ASYNCHRONOUSPROCESS, FD_READ);
    FListening := True;
end;
end;

procedure TCnUDP.Loaded;
begin
inherited;
UpdateBinding;
end;

procedure TCnUDP.SetLocalPort(NewLocalPort: Integer);
begin
if NewLocalPort <> FLocalPort then
begin
    FListening := False;
    if ThisSocket <> 0 then
      closesocket(ThisSocket);
    WSACleanup;
    if WSAStartup($0101, MyWSADATA) = 0 then
    begin
      ThisSocket := Socket(AF_INET, SOCK_DGRAM, 0);
      if ThisSocket = TSocket(INVALID_SOCKET) then
      begin
      WSACleanup;
      SetupLastError;
      Exit;
      end;
    end;
    FLocalPort := NewLocalPort;
    if not (csLoading in ComponentState) then
      UpdateBinding;
end;
end;

function TCnUDP.ResolveRemoteHost(ARemoteHost: string): Boolean;
var
Buf: array of Char;
begin
Result := False;
if not FListening then Exit;
try
    RemoteAddress.sin_addr.S_addr := Inet_Addr(StrPCopy(Buf, ARemoteHost));
    if RemoteAddress.sin_addr.S_addr = SOCKET_ERROR then
    begin
      Wait_Flag := False;
      WSAAsyncGetHostByName(FSocketWindow, WM_ASYNCHRONOUSPROCESS, Buf,
      PChar(RemoteHostS), MAXGETHOSTSTRUCT);
      repeat
      Wait;
      until Wait_Flag;
      if Succeed then
      begin
      with RemoteAddress.sin_addr.S_un_b do
      begin
          s_b1 := remotehostS.h_addr_list^;
          s_b2 := remotehostS.h_addr_list^;
          s_b3 := remotehostS.h_addr_list^;
          s_b4 := remotehostS.h_addr_list^;
      end;
      end;
    end;
except
    ;
end;
if RemoteAddress.sin_addr.S_addr <> 0 then
    Result := True;
if not Result then
    SetupLastError;
end;

function TCnUDP.SendStream(DataStream: TStream; BroadCast: Boolean): Boolean;
var
Buff: Pointer;
begin
GetMem(Buff, DataStream.Size);
try
    DataStream.Position := 0;
    DataStream.Read(Buff^, DataStream.Size);
    Result := SendBuffer(Buff, DataStream.Size, BroadCast);
finally
    FreeMem(Buff);
end;
end;

function TCnUDP.SendBuffer(Buff: Pointer; Length: Integer;
BroadCast: Boolean): Boolean;
var
Hosts: TStrings;
i: Integer;
   
function DoSendBuffer(Buff: Pointer; Length: Integer; Host: string): Boolean;
var
    i: Integer;
begin
    Result := False;
    try
      if not ResolveRemoteHost(Host) then
      Exit;
      RemoteAddress.sin_family := AF_INET;
      RemoteAddress.sin_port := htons(FRemotePort);
      i := SizeOf(RemoteAddress);
      if WinSock.sendto(ThisSocket, Buff^, Length, 0, RemoteAddress, i)
      <> SOCKET_ERROR then
      Result := True
      else
      SetupLastError;
    except
      SetupLastError;
    end;
end;
begin
if BroadCast then
begin
    Result := False;
    Hosts := TStringList.Create;
    try
      GetBroadCastAddress(Hosts);
      for i := 0 to Hosts.Count - 1 do
      if DoSendBuffer(Buff, Length, Hosts) then
          Result := True;
    finally
      Hosts.Free;
    end;
end
else
    Result := DoSendBuffer(Buff, Length, FRemoteHost);
end;

function TCnUDP.GetQueueCount: Integer;
begin
Result := Queue.Count;
end;

procedure TCnUDP.FreeQueueItem(P: Pointer);
var
Rec: PRecvDataRec;
begin
Rec := PRecvDataRec(P);
Rec.FromIP := '';
FreeMem(Rec.Buff);
FreeMem(Rec);
end;

procedure TCnUDP.ClearQueue;
var
Rec: PRecvDataRec;
begin
while Queue.Count > 0 do
begin
    Rec := Queue.Pop;
    FreeQueueItem(Rec);
end;
end;

procedure TCnUDP.ProcessQueue;
var
Rec: PRecvDataRec;
begin
if Procing then Exit;
Procing := True;
try
    while Queue.Count > 0 do
    begin
      Rec := Queue.Pop;
      if Assigned(FOnDataReceived) then
      FOnDataReceived(Self, Rec.Buff, Rec.BuffSize, Rec.FromIP, Rec.FromPort);
      FreeQueueItem(Rec);
    end;
finally
    Procing := False;
end;
end;

procedure TCnUDP.WndProc(var Message: TMessage);
begin
if FListening then
    with Message do
      if Msg = WM_ASYNCHRONOUSPROCESS then
      begin
      if LParamLo = FD_READ then
      begin
          ProcessIncomingdata;
          if not Procing then
            ProcessQueue;
      end
      else
      begin
          Wait_Flag := True;
          if LParamHi > 0 then
            Succeed := False
          else
            Succeed := True;
      end;
      SetEvent(EventHandle);
      end
      else
      Result := DefWindowProc(FSocketWindow, Msg, WParam, LParam);
end;

procedure TCnUDP.ProcessIncomingdata;
var
from: TSockAddr;
i: Integer;
Rec: PRecvDataRec;
IBuff: array of Char;
IBuffSize: Integer;
begin
i := SizeOf(from);
IBuffSize := WinSock.recvfrom(ThisSocket, IBuff, 2048, 0, from, i);
if (IBuffSize > 0) and Assigned(FOnDataReceived) then
begin
    GetMem(Rec, SizeOf(TRecvDataRec));
    ZeroMemory(Rec, SizeOf(TRecvDataRec));
    Rec.FromIP := Format('%d.%d.%d.%d', [Ord(from.sin_addr.S_un_b.S_b1),
      Ord(from.sin_addr.S_un_b.S_b2), Ord(from.sin_addr.S_un_b.S_b3),
      Ord(from.sin_addr.S_un_b.S_b4)]);
    Rec.FromPort := ntohs(from.sin_port);
    GetMem(Rec.Buff, IBuffSize);
    Rec.BuffSize := IBuffSize;
    CopyMemory(Rec.Buff, @IBuff, IBuffSize);
    Queue.Push(Rec);
end;
end;

procedure WaitforSync(Handle: THandle);
begin
repeat
    if MsgWaitForMultipleObjects(1, Handle, False, INFINITE, QS_ALLINPUT)
      = WAIT_OBJECT_0 + 1 then
      Application.ProcessMessages
    else
      Break;
until False;
end;

procedure TCnUDP.Wait;
begin
WaitforSync(EventHandle);
ResetEvent(EventHandle);
end;

procedure TCnUDP.SetupLastError;
begin
FLastError := WSAGetLastError;
end;

function TCnUDP.GetLocalHost: string;
var
wVersionRequested: WORD;
wsaData: TWSAData;
p: PHostEnt;
s: array of char;
begin
wVersionRequested := MAKEWORD(1, 1);
WSAStartup(wVersionRequested, wsaData);
try
    GetHostName(@s, 256);
    p := GetHostByName(@s);
    Result := inet_ntoa(PInAddr(p^.h_addr_list^)^);
finally
    WSACleanup;
end;
end;

end.

eworker 发表于 2010-3-16 16:35:49

socket阻塞和非阻塞的区别



简单点说:

阻塞就是干不完不准回来，   
非组赛就是你先干，我现看看有其他事没有，完了告诉我一声

我们拿最常用的send和recv两个函数来说吧...
比如你调用send函数发送一定的Byte,在系统内部send做的工作其实只是把数据传输(Copy)到TCP/IP协议栈的输出缓冲区,它执行成功并不代表数据已经成功的发送出去了,如果TCP/IP协议栈没有足够的可用缓冲区来保存你Copy过来的数据的话...这时候就体现出阻塞和非阻塞的不同之处了:对于阻塞模式的socket send函数将不返回直到系统缓冲区有足够的空间把你要发送的数据Copy过去以后才返回,而对于非阻塞的socket来说send会立即返回WSAEWOULDDBLOCK告诉调用者说:"发送操作被阻塞了!!!你想办法处理吧..."
对于recv函数,同样道理,该函数的内部工作机制其实是在等待TCP/IP协议栈的接收缓冲区通知它说:嗨,你的数据来了.对于阻塞模式的socket来说如果TCP/IP协议栈的接收缓冲区没有通知一个结果给它它就一直不返回:耗费着系统资源....对于非阻塞模式的socket该函数会马上返回,然后告诉你:WSAEWOULDDBLOCK---"现在没有数据,回头在来看看"


扩展:

在进行网络编程时，我们常常见到同步、异步、阻塞和非阻塞四种调用方式。这些方式彼此概念并不好理解。下面是我对这些术语的理解。
同步
      所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回。按照这个定义，其实绝大多数函数都是同步调用（例如sin, isdigit等）。但是一般而言，我们在说同步、异步的时候，特指那些需要其他部件协作或者需要一定时间完成的任务。最常见的例子就是 SendMessage。该函数发送一个消息给某个窗口，在对方处理完消息之前，这个函数不返回。当对方处理完毕以后，该函数才把消息处理函数所返回的 LRESULT值返回给调用者。
异步
      异步的概念和同步相对。当一个异步过程调用发出后，调用者不能立刻得到结果。实际处理这个调用的部件在完成后，通过状态、通知和回调来通知调用者。以 CAsycSocket类为例（注意，CSocket从CAsyncSocket派生，但是起功能已经由异步转化为同步），当一个客户端通过调用 Connect函数发出一个连接请求后，调用者线程立刻可以朝下运行。当连接真正建立起来以后，socket底层会发送一个消息通知该对象。这里提到执行 部件和调用者通过三种途径返回结果：状态、通知和回调。可以使用哪一种依赖于执行部件的实现，除非执行部件提供多种选择，否则不受调用者控制。如果执行部 件用状态来通知，那么调用者就需要每隔一定时间检查一次，效率就很低（有些初学多线程编程的人，总喜欢用一个循环去检查某个变量的值，这其实是一种很严重 的错误）。如果是使用通知的方式，效率则很高，因为执行部件几乎不需要做额外的操作。至于回调函数，其实和通知没太多区别。
阻塞
   阻塞调用是指调用结果返回之前，当前线程会被挂起。函数只有在得到结果之后才会返回。有人也许会把阻塞调用和同步调用等同起来，实际上他是不同的。对于同 步调用来说，很多时候当前线程还是激活的，只是从逻辑上当前函数没有返回而已。例如，我们在CSocket中调用Receive函数，如果缓冲区中没有数 据，这个函数就会一直等待，直到有数据才返回。而此时，当前线程还会继续处理各种各样的消息。如果主窗口和调用函数在同一个线程中，除非你在特殊的界面操 作函数中调用，其实主界面还是应该可以刷新。socket接收数据的另外一个函数recv则是一个阻塞调用的例子。当socket工作在阻塞模式的时候， 如果没有数据的情况下调用该函数，则当前线程就会被挂起，直到有数据为止。
非阻塞
      非阻塞和阻塞的概念相对应，指在不能立刻得到结果之前，该函数不会阻塞当前线程，而会立刻返回。
对象的阻塞模式和阻塞函数调用
对象是否处于阻塞模式和函数是不是阻塞调用有很强的相关性，但是并不是一一对应的。阻塞对象上可以有非阻塞的调用方式，我们可以通过一定的API去轮询状 态，在适当的时候调用阻塞函数，就可以避免阻塞。而对于非阻塞对象，调用特殊的函数也可以进入阻塞调用。函数select就是这样的一个例子。

阻塞通信

--------------------------------------------------------------------------------

通过重叠通信和计算在许多系统能提高性能。由一个智能通信控制器自动地执行通信的系统是真实的。轻－重线索是取得这种重叠的一种机制。导致好性能的 一个可选的机制是使用非阻塞通信。一个阻塞发送开始调用初始化这个发送操作，但不完成它。在这个消息被从这个发送缓存拷出以前，这个发送开始调用将返回。 需要一个独立的“发送完成”调用完成这个通信，例如，检验从发送缓存拷出的数据。用适当的硬件，在发送被初始化后和它完成以前，来自发送者存储的数据转换 可以和在发送者完成的计算同时进行。类似地，一个非阻塞“接收开始调用”初始化这个接收操作, 但不完成它。在一个消息被存入这个接收缓存以前，这个调用将返回。须要一个独立的“接收完成”调用完成这个接收操作，并检验被接收到这个接收缓存的数据。 用适当的硬件，在接收操作初始化后和它完成以前，到接收者存储的数据转换可以和计算同时进行。非阻塞接收的使用虽着信息较早地在接收缓存位置被提供，也可 以避免系统缓存和存储器到存储器拷贝。

非阻塞发送开始调用能使用与阻塞发送一样的四种模式: 标准, 缓存, 同步和准备好模式。这些具有同样的意义。无论一个匹配接收是否已登入，能开始除“准备好”以外的所有模式的发送；只要一个匹配接收已登入，就能开始一个非 阻塞“准备好”发送。在所有情况下，发送开始调用是局部的：无论其它进程的状态如何，它立刻返回。如果这个调用使得一些系统资源用完，那么它将失败并返回 一个错误代码。高质量的MPI实现应保证这种情况只在“病态”时发生。即，一个MPI实现将能支持大数量挂起非阻塞操作。　　

当数据已被从发送缓存拷出时，这个发送完成调用返回。它可以带有附加的意义，这取决于发送模式。　　

如果发送模式是“同步的”，那么只有一个匹配接收已开始这个发送才能完成。即，一个接收已被登入，并已和这个发送匹配。这时，这个发送完成调用是非 局部的。注意，在接收完成调用发生以前，如果一个同步、非阻塞发送和一个非阻塞接收匹配, 它可以完成。(发送者一“知道”转换将结束，它就能完成，但在接收者“知道”转换将结束以前)。　　

如果发送模式是“缓存”，并没有挂起接收，那么消息必须被缓存。这时，发送完成调用是局部的，而且无论一个匹配接收的状态如何，它必须成功。　　

如果发送模式是标准的，同时这个消息被缓存，那么在一个匹配接收发生以前，发送结束调用可以返回。另一方面，发送完成直到一个匹配接收发生才可以完成，并且这个消息已被拷到接收缓存。　　

非阻塞发送能被用阻塞接收匹配，反过来也可以。 　　

给用户的建议. 一个发送操作的完成, 对于标准模式可以被延迟, 对于同部模式必须延迟, 直到一个匹配接收登入。这两种情况下非阻塞发送的使用允许发送者提前于接收者进行，以便在两进程的速度方面，计算更容忍波动。　　

缓存和准备好模式中的非阻塞发送有一个更有限的影响。一可能一个非阻塞发送将返回，而一个阻塞发送将在数据被从发送者存储拷出后返回。只要在数据拷贝能和计算同时的情况下，非阻塞发送的使用有优点。　　

消息发送模式隐含着由发送者初始化通信。当发送者初始化通信(数据被直接移到接收缓存, 并不要求排队一个挂起发送请求) 时，如果一个接收已登入，这个通信一般将有较低的额外负担。但是，只在匹配发送已发生后，一个接收操作能完成。当非阻塞接收等待发送时，没有阻塞接收，它 的使用允许得到较低的通信额外负担。（给用户的建议结束）。

查看完整版本: DELPHI环境下UDPSOCKET的使用？