Pascal (Lazarus/Delphi)

Thread Pool Size

See more Async Examples

Demonstrates how to set the maximum number of threads in Chilkat's thread pool manager. Also demonstrates how to set a thread pool log file for help in diagnosing unexpected problems. Pascal (Lazarus/Delphi)

program ChilkatDemo;

// Demonstrates using the Chilkat Pascal wrapper via the C bridge DLL.
// Builds as a console application under Lazarus (FPC) or Delphi.

{$IFDEF FPC}
  {$MODE DELPHI}
{$ENDIF}
{$APPTYPE CONSOLE}

uses
  {$IFDEF UNIX}
  cthreads,
  {$ENDIF}
  SysUtils,
  CkDllLoader,
  Chilkat.Global,
  Chilkat.Task,
  Chilkat.Http;

// ---------------------------------------------------------------------------

procedure RunDemo;
var
  success: Boolean;
  glob: TGlobal;
  http1: THttp;
  http2: THttp;
  http3: THttp;
  url1: string;
  url2: string;
  url3: string;
  task1: TTask;
  task2: TTask;
  task3: TTask;
  maxWaitMs: Integer;
  err: string;
  html1: string;
  html2: string;
  html3: string;

begin
  success := False;

  //  This example assumes the Chilkat API to have been previously unlocked.
  //  See Global Unlock Sample for sample code.

  success := False;

  //  Set the maximum number of threads in the Chilkat thread pool to 12.
  //  This means that no more than 12 background worker threads will exist simultaneously.
  //  If more than 12 tasks are queued then some must wait for a worker thread to become free.
  //  Note: The Chilkat thread pool manager thread is a thread distinct from the
  //  worker threads.  It starts when the 1st asynchronous task is Run. 
  glob := TGlobal.Create;
  glob.MaxThreads := 12;

  //  Also, the ThreadPoolLogPath can be set to cause the thread pool manager thread to
  //  keep a log file. This is for the purpose of debugging if unexpected problems occur.
  glob.ThreadPoolLogPath := '/home/users/chilkat/logs/threadPoolLog.txt';

  http1 := THttp.Create;
  http2 := THttp.Create;
  http3 := THttp.Create;

  url1 := 'http://www.marcusmiller.com/';
  url2 := 'http://www.tromboneshorty.com/';
  url3 := 'http://www.jamesmorrison.com/';

  //  Call the async version of the QuickGetStr method to return a task object.
  //  The task object is loaded, but is in the Inert state -- meaning it is
  //  not yet scheduled to run on Chilkat's background thread pool.
  task1 := http1.QuickGetStrAsync(url1);
  if (http1.LastMethodSuccess = False) then
    begin
      WriteLn(http1.LastErrorText);
      Exit;
    end;

  task2 := http2.QuickGetStrAsync(url2);
  if (http2.LastMethodSuccess = False) then
    begin
      WriteLn(http2.LastErrorText);
      task1.Free;
      Exit;
    end;
  task3 := http3.QuickGetStrAsync(url3);
  if (http3.LastMethodSuccess = False) then
    begin
      WriteLn(http3.LastErrorText);
      task1.Free;
      task2.Free;
      Exit;
    end;

  //  At this point we have 3 task objects, each loaded with a Chilkat method call.
  //  Note: At this point no background threads are running.  The thread pool manager
  //  thread is not started -- it will start when the very first task is Run.

  //  Schedule each task for running on the thread pool.  This changes each task's state
  //  from Inert to Live. The thread pool manager thread starts with the 1st task queued.
  //  If the Global.ThreadPoolLogPath property was set, then
  //  the log file would be created (or appended) at this point.
  success := task1.Run();
  //  Assuming success for brevity...
  success := task2.Run();
  success := task3.Run();

  //  The application is now free to do anything else
  //  while the HTML at the URL's are being downloaded in background threads.

  //  In this case, we'll just wait for all three tasks to finish.
  //  All three tasks are running simultaneously in separate background threads.
  //  We can wait for each in any order.  If Wait is called and the task has already
  //  finished (or been canceled), then the Wait method returns immediately.
  maxWaitMs := 20000;
  success := task1.Wait(maxWaitMs);
  success := task2.Wait(maxWaitMs);
  success := task3.Wait(maxWaitMs);
  //  Assuming success for brevity...

  err := 'Task failed or canceled';
  html1 := err;
  html2 := err;
  html3 := err;

  //  Now get the HTML downloaded in each task:
  if ((task1.StatusInt = 7) and (task1.TaskSuccess = True)) then
    begin
      html1 := task1.GetResultString();
    end;
  if ((task2.StatusInt = 7) and (task2.TaskSuccess = True)) then
    begin
      html2 := task2.GetResultString();
    end;
  if ((task3.StatusInt = 7) and (task3.TaskSuccess = True)) then
    begin
      html3 := task3.GetResultString();
    end;

  WriteLn(html1);
  WriteLn('----');
  WriteLn(html2);
  WriteLn('----');
  WriteLn(html3);
  WriteLn('----');

  task1.Free;
  task2.Free;
  task3.Free;


  glob.Free;
  http1.Free;
  http2.Free;
  http3.Free;

end;

// ---------------------------------------------------------------------------

begin

  try
    RunDemo;
  except
    on E: Exception do
      WriteLn('Unhandled exception: ', E.ClassName, ': ', E.Message);
  end;

  WriteLn;
  {$IFDEF MSWINDOWS}
  WriteLn('Press Enter to exit...');
  ReadLn;
  {$ENDIF}
end.