3

我有一个奇怪的问题。我的主窗体上有一个 TTimer，应该触发 500 毫秒。创建表单后。

当我从 IDE 运行它时它工作正常，但是当我在其他 W7 PC 上运行它时，会创建主窗体，但计时器不会触发。（有些组件没有更新）如果我点击一个控件，一切都会更新，计时器会触发，一切都很好。如果我移动表单，所有内容都会更新，但不会启动计时器。如果我在安装了 Delphi 的 PC 上运行它，它工作正常。没问题。

MyForm.OnCreate 中的代码执行得很好。Timer.Enabled := True没有改变。

知道是什么原因造成的吗？我真的被困在这里了。

最好的祝福。

4

2 回答 2

5

有多种可能性：

  1. WM_TIMER 消息仅在您的消息队列为空时传送。如果您的应用程序中的某些内容，或者在其他计算机上运行的另一个应用程序中的某些内容频繁地向窗口句柄发布消息，以至于该窗口的消息队列永远不会清空，则 WM_TIMER 事件将永远不会触发。如果发生这种情况，您可能需要等待正常 TTimer 周期的 10 倍或 20 倍或 30 倍，但事件最终可能会触发。到目前为止，我还没有观察到任何计时器根本不触发的情况，但这当然在理论上是可能的......

  2. 尽管您说您确定计时器已启用（您将其设置为启用），但您可能在代码中的其他地方禁用了它。

  3. 如果你在做一些尝试...除了...结束块并忽略异常，那么可能会发生一些你在其他机器上看不到的不好的事情。

  4. 您的计时器代码可能正在触发，但在计时器上运行的代码中可能会发生异常、崩溃或挂起。

  5. 在您的代码中，您可能有一些 Delphi 事件处理程序，它们创建了一个几乎“无限循环”的情况，因为您编写的一些事件处理程序在您不希望它们触发时触发，从而导致副作用，从而使您的应用程序忙。您提到您正在单击某处并且问题消失了。该点击可能足以中断代码中的其他一些恶性循环。

  6. 您提到它可以在任何安装了 delphi 的 PC 上运行。您是否使用了具有某些限制的第三方控件（例如要求您在调试器中运行？）。或者您的应用程序是否加载了一些未安装在其他计算机上的 DLL 或 BPL？

从一个没有任何内容的全新应用程序开始。添加一个 TTimer。现在在计时器事件上增加一个整数字段值并将该值写入表单的标题。现在在其他机器上运行它。它会正常工作。

现在去看看你写的那一大堆代码，然后决定如何把你那一大堆代码一分为二，找出坏掉的那一半。经过足够的步骤，你会发现你的问题。这里没有人可以为您调试它。

尝试添加一些日志消息，OutputDebugString在其他机器上使用并运行 DebugView，如果您想在另一台机器上查看应用程序的一些内部结构

于 2012-08-16T00:23:43.687 回答
1

老问题我知道，但是想和你分享这块金子，老而金;-)

您也可以将其转换为线程（因为计时器是有限的），我对此做了一个简单的解决方案，一个名为TimerAsThread. 将代码另存为 TimerAsThread.pas。您需要在 extctrls 之后包含此单元或将其包含为最后一个单元。您不必更改代码，它的工作原理完全相同，但现在基于线程。线程是一个单独的进程，如果您想了解更多信息，请在 google 上搜索。

玩得开心。

{*******************************************************}
{                                                       }
{         Delphi VCL Extensions (RX)                    }
{                                                       }
{         Copyright (c) 1996 AO ROSNO                   }
{         Copyright (c) 1997, 1998 Master-Bank          }
{                                                       }
{*******************************************************}

unit TimerAsThread;

interface



uses {$IFDEF WIN32} Windows, {$ELSE} WinTypes, WinProcs, {$ENDIF}
  Messages, SysUtils, Classes;

type

{ TTimer }

  TTimer = class(TComponent)
  private
    FEnabled: Boolean;
    FInterval: Cardinal;
    FOnTimer: TNotifyEvent;
    FWindowHandle: HWND;
{$IFDEF WIN32}
    FSyncEvent: Boolean;
    FThreaded: Boolean;
    FTimerThread: TThread;
    FThreadPriority: TThreadPriority;
    procedure SetThreaded(Value: Boolean);
    procedure SetThreadPriority(Value: TThreadPriority);
{$ENDIF}
    procedure SetEnabled(Value: Boolean);
    procedure SetInterval(Value: Cardinal);
    procedure SetOnTimer(Value: TNotifyEvent);
    procedure UpdateTimer;
    procedure WndProc(var Msg: TMessage);
  protected
    procedure Timer; dynamic;
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
{$IFDEF WIN32}
    procedure Synchronize(Method: TThreadMethod);
{$ENDIF}
  published
    property Enabled: Boolean read FEnabled write SetEnabled default True;
    property Interval: Cardinal read FInterval write SetInterval default 1000;
{$IFDEF WIN32}
    property SyncEvent: Boolean read FSyncEvent write FSyncEvent default True;
    property Threaded: Boolean read FThreaded write SetThreaded default True;
    property ThreadPriority: TThreadPriority read FThreadPriority write
      SetThreadPriority default tpNormal;
{$ENDIF}
    property OnTimer: TNotifyEvent read FOnTimer write SetOnTimer;
  end;

implementation

uses Forms, Consts, VCLUtils;

{$IFDEF WIN32}

{ TTimerThread }

type
  TTimerThread = class(TThread)
  private
    FOwner: TTimer;
    FInterval: Cardinal;
    FException: Exception;
    procedure HandleException;
  protected
    procedure Execute; override;
  public
    constructor Create(Timer: TTimer; Enabled: Boolean);
  end;

constructor TTimerThread.Create(Timer: TTimer; Enabled: Boolean);
begin
  FOwner := Timer;
  inherited Create(not Enabled);
  FInterval := 1000;
  FreeOnTerminate := True;
end;

procedure TTimerThread.HandleException;
begin
  if not (FException is EAbort) then begin
    if Assigned(Application.OnException) then
      Application.OnException(Self, FException)
    else
      Application.ShowException(FException);
  end;
end;

procedure TTimerThread.Execute;

  function ThreadClosed: Boolean;
  begin
   if( Application.Terminated ) and ( NOT Terminated ) then
    Terminate;

   Result := Terminated or Application.Terminated or (FOwner = nil);
  end;

begin
  repeat
    if not ThreadClosed then
      if SleepEx(FInterval, False) = 0 then begin
        if not ThreadClosed and FOwner.FEnabled then
          with FOwner do
            if SyncEvent then Synchronize(Timer)
            else
              try
                Timer;
              except
                on E: Exception do begin
                  FException := E;
                  HandleException;
                end;
              end;
      end;
  until Terminated;
end;

{$ENDIF}

{ TTimer }

constructor TTimer.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  FEnabled := True;
  FInterval := 1000;
{$IFDEF WIN32}
  FSyncEvent := True;
  FThreaded := True;
  FThreadPriority := tpNormal;
  FTimerThread := TTimerThread.Create(Self, False);
{$ELSE}
  FWindowHandle := AllocateHWnd(WndProc);
{$ENDIF}
end;

destructor TTimer.Destroy;
begin
  Destroying;
  FEnabled := False;
  FOnTimer := nil;
{$IFDEF WIN32}
  {TTimerThread(FTimerThread).FOwner := nil;}
//  while FTimerThread.Suspended do FTimerThread.Resume;
  FTimerThread.Terminate;
  {if not SyncEvent then FTimerThread.WaitFor;}
  if FWindowHandle <> 0 then begin
{$ENDIF}
    KillTimer(FWindowHandle, 1);
    DeallocateHWnd(FWindowHandle);
{$IFDEF WIN32}
  end;
{$ENDIF}
  inherited Destroy;
end;

procedure TTimer.WndProc(var Msg: TMessage);
begin
  with Msg do
    if Msg = WM_TIMER then
      try
        Timer;
      except
        Application.HandleException(Self);
      end
    else Result := DefWindowProc(FWindowHandle, Msg, wParam, lParam);
end;

procedure TTimer.UpdateTimer;
begin
{$IFDEF WIN32}
  if FThreaded then begin
    if FWindowHandle <> 0 then begin
      KillTimer(FWindowHandle, 1);
      DeallocateHWnd(FWindowHandle);
      FWindowHandle := 0;
    end;
    if not FTimerThread.Suspended then FTimerThread.Suspend;
    TTimerThread(FTimerThread).FInterval := FInterval;
    if (FInterval <> 0) and FEnabled and Assigned(FOnTimer) then begin
      FTimerThread.Priority := FThreadPriority;
      while FTimerThread.Suspended do FTimerThread.Resume;
    end;
  end
  else begin
    if not FTimerThread.Suspended then FTimerThread.Suspend;
    if FWindowHandle = 0 then FWindowHandle := AllocateHWnd(WndProc)
    else KillTimer(FWindowHandle, 1);
    if (FInterval <> 0) and FEnabled and Assigned(FOnTimer) then
      if SetTimer(FWindowHandle, 1, FInterval, nil) = 0 then
        raise EOutOfResources.Create(ResStr(SNoTimers));
  end;
{$ELSE}
  KillTimer(FWindowHandle, 1);
  if (FInterval <> 0) and FEnabled and Assigned(FOnTimer) then
    if SetTimer(FWindowHandle, 1, FInterval, nil) = 0 then
      raise EOutOfResources.Create(ResStr(SNoTimers));
{$ENDIF}
end;

procedure TTimer.SetEnabled(Value: Boolean);
begin
  if Value <> FEnabled then begin
    FEnabled := Value;
    UpdateTimer;
  end;
end;

procedure TTimer.SetInterval(Value: Cardinal);
begin
  if Value <> FInterval then begin
    FInterval := Value;
    UpdateTimer;
  end;
end;

{$IFDEF WIN32}

procedure TTimer.SetThreaded(Value: Boolean);
begin
  if Value <> FThreaded then begin
    FThreaded := Value;
    UpdateTimer;
  end;
end;

procedure TTimer.SetThreadPriority(Value: TThreadPriority);
begin
  if Value <> FThreadPriority then begin
    FThreadPriority := Value;
    if FThreaded then UpdateTimer;
  end;
end;

procedure TTimer.Synchronize(Method: TThreadMethod);
begin
  if (FTimerThread <> nil) then begin
    with TTimerThread(FTimerThread) do begin
      if Suspended or Terminated then Method
      else TTimerThread(FTimerThread).Synchronize(Method);
    end;
  end
  else Method;
end;

{$ENDIF}

procedure TTimer.SetOnTimer(Value: TNotifyEvent);
begin
  if Assigned(FOnTimer) <> Assigned(Value) then begin
    FOnTimer := Value;
    UpdateTimer;
  end else FOnTimer := Value;
end;

procedure TTimer.Timer;
begin
  if FEnabled and not (csDestroying in ComponentState) and
    Assigned(FOnTimer) then FOnTimer(Self);
end;

end.
于 2018-07-02T22:31:20.187 回答