(Delphi DLL) Thread Pool Size

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.

Chilkat for Delphi Downloads Chilkat non-ActiveX DLL for Delphi Chilkat ActiveX DLL for Delphi * The examples here use the non-ActiveX DLL.

uses
    Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
    Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Global, Task, Http;

...

procedure TForm1.Button1Click(Sender: TObject);
var
chilkatGlob: HCkGlobal;
success: Boolean;
http1: HCkHttp;
http2: HCkHttp;
http3: HCkHttp;
url1: PWideChar;
url2: PWideChar;
url3: PWideChar;
task1: HCkTask;
task2: HCkTask;
task3: HCkTask;
maxWaitMs: Integer;
err: PWideChar;
html1: PWideChar;
html2: PWideChar;
html3: PWideChar;

begin
// All Chilkat classes can be unlocked at once at the beginning of a program
// by calling UnlockBundle.  It requires a Bundle unlock code.
chilkatGlob := CkGlobal_Create();
success := CkGlobal_UnlockBundle(chilkatGlob,'Anything for 30-day trial.');
if (success <> True) then
  begin
    Memo1.Lines.Add(CkGlobal__lastErrorText(chilkatGlob));
    Exit;
  end;

// 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. 
CkGlobal_putMaxThreads(chilkatGlob,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.
CkGlobal_putThreadPoolLogPath(chilkatGlob,'/home/users/chilkat/logs/threadPoolLog.txt');

http1 := CkHttp_Create();
http2 := CkHttp_Create();
http3 := CkHttp_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 := CkHttp_QuickGetStrAsync(http1,url1);
if (CkHttp_getLastMethodSuccess(http1) = False) then
  begin
    Memo1.Lines.Add(CkHttp__lastErrorText(http1));
    Exit;
  end;
task2 := CkHttp_QuickGetStrAsync(http2,url2);
if (CkHttp_getLastMethodSuccess(http2) = False) then
  begin
    Memo1.Lines.Add(CkHttp__lastErrorText(http2));
    CkTask_Dispose(task1);
    Exit;
  end;
task3 := CkHttp_QuickGetStrAsync(http3,url3);
if (CkHttp_getLastMethodSuccess(http3) = False) then
  begin
    Memo1.Lines.Add(CkHttp__lastErrorText(http3));
    CkTask_Dispose(task1);
    CkTask_Dispose(task2);
    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 := CkTask_Run(task1);
// Assuming success for brevity...
success := CkTask_Run(task2);
success := CkTask_Run(task3);

// 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 := CkTask_Wait(task1,maxWaitMs);
success := CkTask_Wait(task2,maxWaitMs);
success := CkTask_Wait(task3,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 ((CkTask_getStatusInt(task1) = 7) and (CkTask_getTaskSuccess(task1) = True)) then
  begin
    html1 := CkTask__getResultString(task1);
  end;
if ((CkTask_getStatusInt(task2) = 7) and (CkTask_getTaskSuccess(task2) = True)) then
  begin
    html2 := CkTask__getResultString(task2);
  end;
if ((CkTask_getStatusInt(task3) = 7) and (CkTask_getTaskSuccess(task3) = True)) then
  begin
    html3 := CkTask__getResultString(task3);
  end;

Memo1.Lines.Add(html1);
Memo1.Lines.Add('----');
Memo1.Lines.Add(html2);
Memo1.Lines.Add('----');
Memo1.Lines.Add(html3);
Memo1.Lines.Add('----');

CkTask_Dispose(task1);
CkTask_Dispose(task2);
CkTask_Dispose(task3);

CkGlobal_Dispose(chilkatGlob);
CkHttp_Dispose(http1);
CkHttp_Dispose(http2);
CkHttp_Dispose(http3);

end;