并行 ping 多个网络设备的最佳方法是什么？

Question

我通过迭代 ping 轮询网络中的许多设备（超过 300 个）。

该程序按顺序轮询设备，因此速度很慢。 我想提高轮询的速度。

在 Delphi 7 中有一些方法可以做到这一点：

1. 每个设备都有一个执行 ping 操作的线程。手动管理线程。
2. 学习和使用 Indy 10。需要示例。
3. 使用基于窗口消息的重叠 I/O。
4. 根据事件使用完成端口。

什么更快、更容易？请提供一些示例或链接。

Answer 1

Windows 上不推荐直接 ICMP 访问。 Windows 上对 ICMP 协议的直接访问受到控制。由于恶意使用 ICMP/ping/traceroute 风格的原始套接字，我相信在某些版本的 Windows 上您将需要使用 Windows 自己的 api。特别是 Windows XP、Vista 和 Windows 7，不允许用户程序访问原始套接字。

我已经使用了 ICMP.dll 中的预设功能，这是一些 Delphi ping 组件所做的，但下面的评论提醒我这样一个事实：这被认为是“使用未记录的 API 接口”。

下面是主要 delphi ping 组件调用本身的示例：

function TICMP.ping: pIcmpEchoReply;
{var  }
begin
  // Get/Set address to ping
  if ResolveAddress = True then begin
    // Send packet and block till timeout or response
    _NPkts := _IcmpSendEcho(_hICMP, _Address,
                            _pEchoRequestData, _EchoRequestSize,
                            @_IPOptions,
                            _pIPEchoReply, _EchoReplySize,
                           _TimeOut);
    if _NPkts = 0 then begin
      result := nil;
      status := CICMP_NO_RESPONSE;
    end else begin
      result := _pIPEchoReply;
    end;
  end else begin
    status := CICMP_RESOLVE_ERROR;
    result := nil;
  end;
end;

我相信大多数现代 Ping 组件实现将基于与上面类似的代码，并且我已使用它在后台线程中运行此 ping 操作，没有任何问题。 （演示程序包含在下面的链接中）。

基于 ICMP.DLL 的演示的完整示例源代码位于此处。

更新 更现代的 IPHLPAPI.DLL 示例位于 About.com

Answer 2

这里有一篇来自Delphi3000的文章展示了如何使用IOCP创建线程池。我不是这段代码的作者，但作者的信息在源代码中。

我在这里重新发布评论和代码：

现在大家应该明白什么了吧
线程是什么，线程的原理
等等。对于那些有需要的人来说，
线程的简单功能是
将处理从一个线程分离到
另一个，允许并发和
并行执行。主要原理
线程的数量也很简单，内存
分配的引用之间
必须对线程进行编组以确保
访问安全。有一些
其他原则但这确实是
值得关心的人。

还有……

线程安全队列将允许
添加和删​​除多个线程，
将值推入和弹出
按先开先关安全排队
基础。拥有高效、良好的
写队列你可以有一个高度
开发中有用的组件
线程应用程序，从帮助
使用线程安全日志记录，
异步处理请求。

线程池只是一个线程或一个
最多的线程数
常用于管理队列
请求。例如网络服务器
这将有一个连续的队列
需要处理的请求使用
线程池来管理http
请求，或者 COM+ 或 DCOM 服务器
使用线程池来处理rpc
请求。这样做是这样的
处理过程中的影响较小
向另一个请求，假设你跑了 3
同步请求和第一个
请求需要 1 分钟才能完成，
后两个请求无法完成
添加在上面至少 1 分钟
有自己的时间来处理，并且
大多数客户这不是
可以接受。

那么如何做到这一点..

从队列开始！！

Delphi确实提供了一个TQueue对象
这是可用的，但是
不幸的是不是线程安全的也不是
确实效率太高了，但是人
应该查看 Contnrs.pas 文件
看看borland如何在那里写堆栈和
队列。主要只有两个
队列所需的函数，这些
是添加和删除/推送和弹出。
添加/推送将添加一个值、指针或
对象到队列末尾。和
删除/弹出将删除并返回
队列中的第一个值。

您可以从 TQueue 对象派生
并覆盖受保护的方法和
添加关键部分，这将
给你一些帮助，但我会
希望我的队列等到新的
请求在队列中，并将
线程进入静止状态
等待新的请求。这可能是
通过添加互斥体或信号来完成
事件，但有一个更简单的方法。这
windows api 提供 IO 完成
队列为我们提供了线程
安全访问队列和状态
等待新请求时休息
队列。

实现线程池

线程池将会非常
简单并且可以管理 x 数量
所需线程并传递每个队列
请求提供的事件
已处理。很少有需要
实现一个 TThread 类和你的
要实现的逻辑和
封装在执行事件中
类，因此一个简单的
可以创建TSimpleThread类
它将执行任何方法中的任何方法
对象处于另一个对象的上下文中
线。一旦人们明白了这一点，
所有你需要关心的事情
已分配内存。

这是它的实现方式。

TThreadQueue 和 TThreadPool
实施

(* Implemented for Delphi3000.com Articles, 11/01/2004
        Chris Baldwin
        Director & Chief Architect
        Alive Technology Limited
        http://www.alivetechnology.com
*)
unit ThreadUtilities;

uses Windows, SysUtils, Classes;

type
    EThreadStackFinalized = class(Exception);
    TSimpleThread = class;

    // Thread Safe Pointer Queue
    TThreadQueue = class
    private
        FFinalized: Boolean;
        FIOQueue: THandle;
    public
        constructor Create;
        destructor Destroy; override;
        procedure Finalize;
        procedure Push(Data: Pointer);
        function Pop(var Data: Pointer): Boolean;
        property Finalized: Boolean read FFinalized;
    end;

    TThreadExecuteEvent = procedure (Thread: TThread) of object;

    TSimpleThread = class(TThread)
    private
        FExecuteEvent: TThreadExecuteEvent;
    protected
        procedure Execute(); override;
    public
        constructor Create(CreateSuspended: Boolean; ExecuteEvent: TThreadExecuteEvent; AFreeOnTerminate: Boolean);
    end;

    TThreadPoolEvent = procedure (Data: Pointer; AThread: TThread) of Object;

    TThreadPool = class(TObject)
    private
        FThreads: TList;
        FThreadQueue: TThreadQueue;
        FHandlePoolEvent: TThreadPoolEvent;
        procedure DoHandleThreadExecute(Thread: TThread);
    public
        constructor Create( HandlePoolEvent: TThreadPoolEvent; MaxThreads: Integer = 1); virtual;
        destructor Destroy; override;
        procedure Add(const Data: Pointer);
    end;

implementation

{ TThreadQueue }

constructor TThreadQueue.Create;
begin
    //-- Create IO Completion Queue
    FIOQueue := CreateIOCompletionPort(INVALID_HANDLE_VALUE, 0, 0, 0);
    FFinalized := False;
end;

destructor TThreadQueue.Destroy;
begin
    //-- Destroy Completion Queue
    if (FIOQueue <> 0) then
        CloseHandle(FIOQueue);
    inherited;
end;

procedure TThreadQueue.Finalize;
begin
    //-- Post a finialize pointer on to the queue
    PostQueuedCompletionStatus(FIOQueue, 0, 0, Pointer($FFFFFFFF));
    FFinalized := True;
end;

(* Pop will return false if the queue is completed *)
function TThreadQueue.Pop(var Data: Pointer): Boolean;
var
    A: Cardinal;
    OL: POverLapped;
begin
    Result := True;
    if (not FFinalized) then
//-- Remove/Pop the first pointer from the queue or wait
        GetQueuedCompletionStatus(FIOQueue, A, Cardinal(Data), OL, INFINITE);

    //-- Check if we have finalized the queue for completion
    if FFinalized or (OL = Pointer($FFFFFFFF)) then begin
        Data := nil;
        Result := False;
        Finalize;
    end;
end;

procedure TThreadQueue.Push(Data: Pointer);
begin
    if FFinalized then
        Raise EThreadStackFinalized.Create('Stack is finalized');
    //-- Add/Push a pointer on to the end of the queue
    PostQueuedCompletionStatus(FIOQueue, 0, Cardinal(Data), nil);
end;

{ TSimpleThread }

constructor TSimpleThread.Create(CreateSuspended: Boolean;
  ExecuteEvent: TThreadExecuteEvent; AFreeOnTerminate: Boolean);
begin
    FreeOnTerminate := AFreeOnTerminate;
    FExecuteEvent := ExecuteEvent;
    inherited Create(CreateSuspended);
end;

procedure TSimpleThread.Execute;
begin
    if Assigned(FExecuteEvent) then
        FExecuteEvent(Self);
end;

{ TThreadPool }

procedure TThreadPool.Add(const Data: Pointer);
begin
    FThreadQueue.Push(Data);
end;

constructor TThreadPool.Create(HandlePoolEvent: TThreadPoolEvent;
  MaxThreads: Integer);
begin
    FHandlePoolEvent := HandlePoolEvent;
    FThreadQueue := TThreadQueue.Create;
    FThreads := TList.Create;
    while FThreads.Count < MaxThreads do
        FThreads.Add(TSimpleThread.Create(False, DoHandleThreadExecute, False));
end;

destructor TThreadPool.Destroy;
var
    t: Integer;
begin
    FThreadQueue.Finalize;
    for t := 0 to FThreads.Count-1 do
        TThread(FThreads[t]).Terminate;
    while (FThreads.Count > 0) do begin
        TThread(FThreads[0]).WaitFor;
        TThread(FThreads[0]).Free;
        FThreads.Delete(0);
    end;
    FThreadQueue.Free;
    FThreads.Free;
    inherited;
end;

procedure TThreadPool.DoHandleThreadExecute(Thread: TThread);
var
    Data: Pointer;
begin
    while FThreadQueue.Pop(Data) and (not TSimpleThread(Thread).Terminated) do begin
        try
            FHandlePoolEvent(Data, Thread);
        except
        end;
    end;
end;

end. 

正如你所看到的，它非常直
前进，这样你就可以
非常容易地实现任何排队
通过线程和任何其他请求
要求的要求类型
线程可以使用这些来完成
反对并为您节省大量时间
努力。

您可以使用它来对请求进行排队
从单线程到多线程，
或对来自多个的请求进行排队
线程减少到一个线程，这使得
这是一个非常好的解决方案。

以下是一些使用这些的示例
对象。

线程安全日志记录

允许多个
线程异步写入
日志文件。

uses Windows, ThreadUtilities,...;

type
    PLogRequest = ^TLogRequest;
    TLogRequest = record
        LogText: String;
    end;

    TThreadFileLog = class(TObject)
    private
        FFileName: String;
        FThreadPool: TThreadPool;
        procedure HandleLogRequest(Data: Pointer; AThread: TThread);
    public
        constructor Create(const FileName: string);
        destructor Destroy; override;
        procedure Log(const LogText: string);
    end;

implementation

(* Simple reuse of a logtofile function for example *)
procedure LogToFile(const FileName, LogString: String);
var
    F: TextFile;
begin
    AssignFile(F, FileName);
    if not FileExists(FileName) then
        Rewrite(F)
    else
        Append(F);
    try
        Writeln(F, DateTimeToStr(Now) + ': ' + LogString);
    finally
        CloseFile(F);
    end;
end;

constructor TThreadFileLog.Create(const FileName: string);
begin
    FFileName := FileName;
    //-- Pool of one thread to handle queue of logs
    FThreadPool := TThreadPool.Create(HandleLogRequest, 1);
end;

destructor TThreadFileLog.Destroy;
begin
    FThreadPool.Free;
    inherited;
end;

procedure TThreadFileLog.HandleLogRequest(Data: Pointer; AThread: TThread);
var
    Request: PLogRequest;
begin
    Request := Data;
    try
        LogToFile(FFileName, Request^.LogText);
    finally
        Dispose(Request);
    end;
end;

procedure TThreadFileLog.Log(const LogText: string);
var
    Request: PLogRequest;
begin
    New(Request);
    Request^.LogText := LogText;
    FThreadPool.Add(Request);
end;

因为这是记录到一个文件，所以它会
将所有请求处理为一个
线程，但你可以发送丰富的电子邮件
具有更高线程的通知
计算，甚至更好，处理
分析正在发生的事情或
我将在你的程序中执行以下步骤
在另一篇文章中演示如下
现在已经很长了。

现在我就留给你这个，
享受..如果有的话请发表评论
人们被困住的任何事情。

克里斯

Answer 3

您是否需要网络上每台机器的响应，或者这 300 台机器只是更大网络的子集？

如果您需要每台机器的响应，您可以考虑使用广播地址 或 多播地址 用于您的回显请求。

Answer 4

请尝试 Linux 的“chknodes”并行 ping，它将向网络的所有节点发送单个 ping。如果指定的话，它还会进行 dns 反向查找并请求 http 响应。它完全用 bash 编写，即您可以轻松检查它或根据您的需要修改它。以下是帮助的打印输出：

chknodes -h

chknodes ---- 快速并行 ping

chknodes [-l|--log] [-h|--help] [-H|--http] [-u|--uninstall ] [-v|--版本] [-V|--详细]

-l | --log 记录到文件
-h | --help 显示此帮助屏幕
-H | --http 还检查 http 响应
-n | --names 还获取主机名
-u | --uninstall 删除安装
-v | --version 显示版本
-V | --verbose 显示 ping 到的每个 ip 地址

您需要为其提供执行权限（就像任何 sh/bash 脚本一样）才能运行它：

chmod +x chknodes

在第一次运行时，即

./chknodes

它会建议将自身安装到 /usr/local/bin/ chknodes，之后给予

chknodes

就足够了。您可以在这里找到它：

www.homelinuxpc.com/download/chknodes

Answer 5

用 ICMP 淹没网络并不是一个好主意。

您可能需要考虑某种线程池并对 ping 请求进行排队，并使用固定数量的线程来执行请求。

Answer 6

我个人会选择 IOCP。我在 NexusDB 中的传输实现中非常成功地使用了它。

如果您想使用阻塞套接字和线程并行执行 300 个发送/接收周期，则最终需要 300 个线程。

使用IOCP，将套接字与IOCP关联后，您可以执行300个发送操作，并且它们将在操作完成之前立即返回。当操作完成时，所谓的完成包将在 IOCP 中排队。然后，您有一个线程池在 IOCP 上等待，操作系统会在完成数据包进入时唤醒它们。为了响应已完成的发送操作，您可以执行接收操作。接收操作也会立即返回，一旦实际完成，就会排队到 IOCP。

IOCP 的真正特殊之处在于它知道哪些线程属于它并且当前正在处理完成包。并且，只有当活动线程总数（不处于内核模式等待状态）低于 IOCP 的并发数（默认情况下等于机器上可用的逻辑核心数）时，IOCP 才会唤醒新线程。另外，如果有线程在 IOCP 上等待完成包（尽管完成包正在排队，但尚未启动，因为活动线程数等于并发数），当前正在处理的线程之一完成包由于任何原因进入内核模式等待状态，等待线程之一被启动。

返回 IOCP 的线程按 LIFO 顺序拾取完成包。也就是说，如果一个线程正在返回 IOCP，并且还有仍在等待的完成包，则该线程会直接拾取下一个完成包，而不是进入等待状态并唤醒等待时间最长的线程。

在最佳条件下，你将有等于可用核心数量的线程同时运行（每个核心一个），拾取下一个完成包，处理它，返回到IOCP并直接拾取下一个完成包，所有这些都无需进入内核模式等待状态或必须进行线程上下文切换。

如果您有 300 个线程并阻塞操作，那么您不仅会浪费至少 300 MB 地址空间（用于堆栈的保留空间），而且当一个线程进入等待状态（等待发送或接收完成），并且下一个线程已完成发送或接收唤醒。 – 托尔斯滕·恩格勒 12 小时前