(Perl) 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 Perl Downloads Perl Module for Windows, MacOS, Linux, Alpine Linux, Solaris

use chilkat();

# All Chilkat classes can be unlocked at once at the beginning of a program
# by calling UnlockBundle.  It requires a Bundle unlock code.
$chilkatGlob = chilkat::CkGlobal->new();
$success = $chilkatGlob->UnlockBundle("Anything for 30-day trial.");
if ($success != 1) {
    print $chilkatGlob->lastErrorText() . "\r\n";
    exit;
}

# 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. 
$chilkatGlob->put_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.
$chilkatGlob->put_ThreadPoolLogPath("/home/users/chilkat/logs/threadPoolLog.txt");

$http1 = chilkat::CkHttp->new();
$http2 = chilkat::CkHttp->new();
$http3 = chilkat::CkHttp->new();

$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 is a Task
$task1 = $http1->QuickGetStrAsync($url1);
if ($http1->get_LastMethodSuccess() == 0) {
    print $http1->lastErrorText() . "\r\n";
    exit;
}

# task2 is a Task
$task2 = $http2->QuickGetStrAsync($url2);
if ($http2->get_LastMethodSuccess() == 0) {
    print $http2->lastErrorText() . "\r\n";

    exit;
}

# task3 is a Task
$task3 = $http3->QuickGetStrAsync($url3);
if ($http3->get_LastMethodSuccess() == 0) {
    print $http3->lastErrorText() . "\r\n";

    exit;
}

# 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->get_StatusInt() == 7) and ($task1->get_TaskSuccess() == 1)) {
    $html1 = $task1->getResultString();
}

if (($task2->get_StatusInt() == 7) and ($task2->get_TaskSuccess() == 1)) {
    $html2 = $task2->getResultString();
}

if (($task3->get_StatusInt() == 7) and ($task3->get_TaskSuccess() == 1)) {
    $html3 = $task3->getResultString();
}

print $html1 . "\r\n";
print "----" . "\r\n";
print $html2 . "\r\n";
print "----" . "\r\n";
print $html3 . "\r\n";
print "----" . "\r\n";