服务应用程序中的 PostMessage

Question

有一个问题我无法解决。 我在 Delphi 中创建了两个服务应用程序并尝试在其中发布消息。 当然，此类应用程序中没有窗口，PostMessage 需要窗口句柄参数来发送消息。

因此，我使用 AllocateHWnd(MyMethod: TWndMethod) 函数创建了一个窗口句柄，并将我希望在收到消息时调用的过程作为“MyMethod”参数传递。 如果它是一个窗口应用程序，则使用 AllocateHWnd 方法返回的句柄调用 PostMessage() 肯定会发送一条消息，然后该消息将由“MyMethod”过程接收。

然而，在我的服务应用程序中情况有所不同。 我不明白为什么，但在其中一种情况下，以这种方式发布消息效果很好，而在第二种情况下则不然（根本没有收到消息）。 仅当服务停止时，我才注意到“MyMethod”收到两条消息：WM_DESTROY 和 WM_NCDESTROY。 此过程永远不会收到我使用 PostMessage 发送的消息。 另一方面，第一个服务总是接收我发送的所有消息。

您能否给我一个线索，帮助我找到第二个服务未收到我的消息的原因？ 我不知道它们有何不同。 我检查了服务的设置，它们似乎是相同的。 为什么其中一个可以正常工作而第二个却不能（就发送消息而言）？

感谢您的任何建议。 马吕斯。

Answer 1

如果没有更多信息，将很难帮助您调试此问题，特别是为什么它在一个服务中有效但在另一个服务中无效。 但是：

您可能不想尝试解决代码中的问题，而是希望完全删除窗口，并使用 PostThreadMessage() 而不是 PostMessage()。 为了使消息发布正常工作，您需要一个消息循环，但不一定需要接收窗口。

编辑：我正在尝试一次性回复您的所有答案。

首先 - 如果您想让自己的生活变得轻松，您应该真正查看 OmniThreadLibrary by gabr。 我不知道它是否在 Windows 服务应用程序中工作，我什至不知道是否已经尝试过。 你可以去论坛问一下。 然而，它有很多很棒的功能，值得研究，即使只是为了学习效果。

当然，您也可以自己编写此程序，并且对于 Delphi 2007 之前的 Delphi 版本，您必须这样做。我将简单地添加我们内部库中的一些片段，该库已经发展了多年，并且可以在几十个程序中运行。 但我并不声称它没有错误。 您可以将其与您的代码进行比较，如果有任何问题，请随时询问，我会尽力澄清。

这是工作线程基类的简化 Execute() 方法：

procedure TCustomTestThread.Execute;
var
  Msg: TMsg;
begin
  try
    while not Terminated do begin
      if (integer(GetMessage(Msg, HWND(0), 0, 0)) = -1) or Terminated then
        break;
      TranslateMessage(Msg);
      DispatchMessage(Msg);

      if Msg.Message = WM_USER then begin
        // handle differently according to wParam and lParam
        // ...
      end;
    end;
  except
    on E: Exception do begin
      ...
    end;
  end;
end;

重要的是不要让异常得不到处理，因此所有内容都有一个顶级异常处理程序。 您对异常执行的操作是您的选择，并且取决于应用程序，但必须捕获所有异常，否则应用程序将被终止。 在服务中，您唯一的选择可能就是记录它们。

有一个特殊的方法来启动线程关闭，因为线程在GetMessage()内部时需要被唤醒：

procedure TCustomTestThread.Shutdown;
begin
  Terminate;
  Cancel; // internal method dealing with worker objects used in thread
  DoSendMessage(WM_QUIT);
end;

procedure TCustomTestThread.DoSendMessage(AMessage: Cardinal;
  AWParam: integer = 0; ALParam: integer = 0);
begin
  PostThreadMessage(ThreadID, AMessage, AWParam, ALParam);
end;

发送WM_QUIT将导致消息循环退出。 然而，存在一个问题，即后代类中的代码可能依赖于线程关闭期间正确处理的 Windows 消息，尤其是在使用 COM 接口时。 这就是为什么使用以下代码而不是简单的 WaitFor() 来释放所有正在运行的线程：

procedure TCustomTestController.BeforeDestruction;
var
  i: integer;
  ThreadHandle: THandle;
  WaitRes: LongWord;
  Msg: TMsg;
begin
  inherited;
  for i := Low(fPositionThreads) to High(fPositionThreads) do begin
    if fPositionThreads[i] <> nil then try
      ThreadHandle := fPositionThreads[i].Handle;
      fPositionThreads[i].Shutdown;
      while TRUE do begin
        WaitRes := MsgWaitForMultipleObjects(1, ThreadHandle, FALSE, 30000,
          QS_POSTMESSAGE or QS_SENDMESSAGE);
        if WaitRes = WAIT_OBJECT_0 then begin
          FreeAndNil(fPositionThreads[i]);
          break;
        end;
        if WaitRes = WAIT_TIMEOUT then
          break;

        while PeekMessage(Msg, 0, 0, 0, PM_REMOVE) do begin
          TranslateMessage(Msg);
          DispatchMessage(Msg);
        end;
      end;
    except
      on E: Exception do
        // ...
    end;
    fPositionThreads[i] := nil;
  end;
end;

这是在重写的 BeforeDestruction() 方法中，因为需要释放所有线程在后代控制器类的析构函数开始释放线程可能使用的任何对象之前。

Answer 2

我建议您考虑使用命名管道进行 IPC。 这就是它们的设计目的：

寻找进程间通信中使用的 Windows 消息的替代方案

Answer 3

正如 Mghie 提到的，您需要一个消息处理循环。 这就是 PeekMessage 正确返回消息的原因。 并不是消息不存在，而是您没有处理它们。 在标准应用程序中，Delphi 创建一个 TApplication 类并调用 Application.Run。 这是普通应用程序的消息处理循环。 它基本上包括：

  repeat
    try
      HandleMessage;
    except
      HandleException(Self);
    end;
  until Terminated;

如果您希望服务应用程序处理消息，您将需要执行相同类型的工作。

这里有一个使用服务和处理 PostThreadMessage 调度的示例 。 请记住，正如 Mick 提到的，您不能在不同安全上下文的应用程序之间使用消息处理（特别是在 Vista 中）。 您应该使用命名管道或类似的。 Microsoft 在此处对此进行了讨论。

编辑：

根据您发布的代码片段，您可能只是在解决线程问题。 AllocHWnd 不是线程安全的。 有关详细信息，请参阅此处问题的解释以及在线程中正常工作的版本。

当然，这仍然让我们回到为什么不使用 PostThreadMessage 的原因。 根据代码示例的结构方式，将消息处理作为线程的函数，然后将其传递到类中进行处理是很简单的。

Answer 4

感谢您的所有回答。 我想我们可以忘记这个问题。 我创建了一个新的服务应用程序并执行了快速的消息发布测试。 消息已正确传递，因此我希望现在可以声明，正常情况下一切正常，仅我描述的一项服务出现问题。 我知道这很愚蠢，但我只会尝试将代码片段从“坏”服务复制到新服务中。 也许这会帮助我找到问题的原因。

我希望我现在可以认为消息等待循环是不必要的，只要没有它一切都可以正常工作，不是吗？

如果说到权限，微软表示：“UAC使用WIM来阻止Windows消息在不同权限级别的进程之间发送”。 我的 Vista 的 UAC 已关闭，并且我没有为我描述的那些服务设置任何权限。 除此之外，我不在不同进程之间发送消息。 消息在一个进程内发送。

为了让您了解我正在做什么，我将向您展示测试服务应用程序中的代码片段。

uses ...;

type
  TMyThread = class;
  TMyClass = class
  private
    FThread: TMyThread;
    procedure ReadMessage(var Msg: TMessage);
  public
    FHandle: HWND;
    constructor Create;
    destructor Destroy; override;
  end;

  TMyThread = class(TThread)
  private
    FMyClass: TMyClass;
  protected
    procedure Execute; override;
    constructor Create(MyClass: TMyClass); reintroduce;
  end;

implementation

{ TMyClass }

constructor TMyClass.Create;
begin
  inherited Create;
  FHandle := AllocateHWnd(ReadMessage);
  FThread := TMyThread.Create(Self);
end;

destructor TMyClass.Destroy;
begin
  FThread.Terminate;
  FThread.WaitFor;
  FThread.Free;
  DeallocateHWnd(FHandle);
  inherited Destroy;
end;

procedure TMyClass.ReadMessage(var Msg: TMessage);
begin
  Log.Log('message read: ' + IntToStr(Msg.Msg));
end;

{ TMyThread }

constructor TMyThread.Create(MyClass: TMyClass);
begin
  inherited Create(True);
  FMyClass := MyClass;
  Resume;
end;

procedure TMyThread.Execute;
begin
  while not Terminated do
  begin
    //do some work and
    //send a message when finished
    if PostMessage(FMyClass.FHandle, WM_USER, 0, 0) then
      Log.Log('message sent')
    else
      Log.Log('message not sent: ' + SysErrorMessage(GetLastError));
    //do something else...
    Sleep(1000);
  end;
end;

这只是一个示例，但我的真实代码的运行基于相同的想法。 当您创建此类的对象时，它将创建一个线程，该线程将开始向该类发送消息。 Log.Log() 将数据保存到文本文件中。 当我在新的服务应用程序中使用此代码时，一切正常。 当我将其放入“损坏”服务时，它没有。 请注意，我不使用任何消息等待循环来接收消息。 我创建了一个新服务，然后将上面的代码放入其中，然后创建了该类的一个对象。 就这样。

如果我知道为什么这在“损坏的”服务中不起作用，我会写下来。

感谢您为我付出的时间。

马吕斯。

Answer 5

这是我要尝试的：

• 检查 PostMessage 的返回值和 GetLastError
• 这是 Vista/2008 机器吗？ 如果是，请检查发送应用程序是否有足够的权限来发送消息。

我需要更多信息才能进一步帮助您。

Answer 6

我花了很长时间试图找出未收到消息的原因。 正如我在代码片段中所示，该类的构造函数创建了一个窗口句柄，我用它来发送消息。 只要该类是由主线程构造的，窗口句柄（如果我理解正确的话）就存在于主线程的上下文中，一切都工作正常，默认情况下，等待消息。 在“损坏的”服务中，正如我错误地调用的那样，我的类是由另一个线程创建的，因此句柄必须存在于该线程的上下文中。 因此，当我使用此窗口句柄发送消息时，它们是由该线程接收的，而不是由主线程接收的。 由于该线程没有任何消息等待循环，因此根本没有收到我的消息。
我只是不知道它是这样运作的。 为了以简单的方式解决问题，我在主线程中创建并销毁该类，即使我在第二个线程中使用它。

感谢您的时间以及您给我的所有信息。

Answer 7

Mghie，我认为你是完全正确的。 我是这样实现消息等待循环的：

procedure TAsyncSerialPort.Execute;
var
  Msg: tagMSG;
begin
  while GetMessage(Msg, 0, 0, 0) do
  begin
    {thread message}
    if Msg.hwnd = 0 then
    begin
      case Msg.message of
        WM_DATA_READ: Log.Log('data read');
        WM_READ_TIMEOUT: Log.Log('read timeout');
        WM_DATA_WRITTEN: Log.Log('data written');
        WM_COMM_ERROR: Log.Log('comm error');
      else
        DispatchMessage(Msg);
      end;
    end
    else
      DispatchMessage(Msg);
  end;
end;

我是第一次这样做，所以请您检查一下代码是否正确？ 事实上，这是我真实的类代码片段（日志将替换为真实代码）。 它处理重叠的通信端口。 有两个线程向上面的线程发送线程消息，通知它它们从通讯端口写入或接收了一些数据等。当线程收到这样的消息时，它会采取行动 - 它从队列中获取接收到的数据，线程首先将其放置在其中，然后调用外部方法来分析接收到的数据。 我不想透露细节，因为这并不重要:)。 我发送这样的线程消息：PostThreadMessage(MyThreadId, WM_DATA_READ, 0, 0)。

正如我所检查的，这段代码工作正常，但我想确保一切都正确，所以我向你询问这一点。 如果您能回答，我将不胜感激。

为了释放线程，我执行以下操作：

destructor TAsyncSerialPort.Destroy;
begin
  {send a quit message to the thread so that GetMessage returns false and the loop ends}
  PostThreadMessage(ThreadID, WM_QUIT, 0, 0);

  {terminate the thread but wait until it finishes before the following objects 
  (critical sections) are destroyed for the thread might use them before it quits}
  Terminate;
  if Suspended then
    Resume;
  WaitFor;

  FreeAndNil(FLock);
  FreeAndNil(FCallMethodsLock);
  inherited Destroy;
end;

我希望这是结束消息循环的正确方法。

非常感谢您的帮助。

顺便说一句，我希望我的英语是可以理解的，不是吗？ :) 抱歉，如果您很难理解我的意思。

Answer 8

线程中的消息循环有一个技巧。 Windows 不会立即为线程创建消息队列，因此有时向线程发布消息会失败。 详细信息位于此处。 在我的消息循环线程中，我使用 MS 提出的技术：

constructor TMsgLoopThread.Create;
begin
  inherited Create(True);
  FEvMsgQueueReady := CreateEvent(nil, True, False, nil);
  if FEvMsgQueueReady = 0 then
    Error('CreateEvent: '+LastErrMsg);
end;

procedure TMsgLoopThread.Execute;
var
  MsgRec: TMsg;
begin
  // Call fake PeekMessage for OS to create message queue for the thread.
  // When it finishes, signal the event. In the main app execution will wait
  // for this event.
  PeekMessage(MsgRec, 0, WM_USER, WM_USER, PM_NOREMOVE);
  SetEvent(FEvMsgQueueReady);

  ...
end;

// Start the thread with waitinig for it to get ready
function TMsgLoopThread.Start(WaitInterval: DWORD): DWORD;
begin
  inherited Start;
  Result := WaitForSingleObject(FEvMsgQueueReady, WaitInterval);
end;

但在你的情况下，我强烈建议使用其他 IPC 方法。