(C#) 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 .NET Downloads Chilkat .NET Framework Chilkat for .NET Core

// All Chilkat classes can be unlocked at once at the beginning of a program
// by calling UnlockBundle.  It requires a Bundle unlock code.
Chilkat.Global chilkatGlob = new Chilkat.Global();
bool success = chilkatGlob.UnlockBundle("Anything for 30-day trial.");
if (success != true) {
    Debug.WriteLine(chilkatGlob.LastErrorText);
    return;
}

// 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.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.ThreadPoolLogPath = "/home/users/chilkat/logs/threadPoolLog.txt";

Chilkat.Http http1 = new Chilkat.Http();
Chilkat.Http http2 = new Chilkat.Http();
Chilkat.Http http3 = new Chilkat.Http();

string url1 = "http://www.marcusmiller.com/";
string url2 = "http://www.tromboneshorty.com/";
string 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.
Chilkat.Task task1 = http1.QuickGetStrAsync(url1);
if (http1.LastMethodSuccess == false) {
    Debug.WriteLine(http1.LastErrorText);
    return;
}

Chilkat.Task task2 = http2.QuickGetStrAsync(url2);
if (http2.LastMethodSuccess == false) {
    Debug.WriteLine(http2.LastErrorText);

    return;
}

Chilkat.Task task3 = http3.QuickGetStrAsync(url3);
if (http3.LastMethodSuccess == false) {
    Debug.WriteLine(http3.LastErrorText);

    return;
}

// 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.
int maxWaitMs = 20000;
success = task1.Wait(maxWaitMs);
success = task2.Wait(maxWaitMs);
success = task3.Wait(maxWaitMs);
// Assuming success for brevity...

string err = "Task failed or canceled";
string html1 = err;
string html2 = err;
string html3 = err;

// Now get the HTML downloaded in each task:
if ((task1.StatusInt == 7) && (task1.TaskSuccess == true)) {
    html1 = task1.GetResultString();
}

if ((task2.StatusInt == 7) && (task2.TaskSuccess == true)) {
    html2 = task2.GetResultString();
}

if ((task3.StatusInt == 7) && (task3.TaskSuccess == true)) {
    html3 = task3.GetResultString();
}

Debug.WriteLine(html1);
Debug.WriteLine("----");
Debug.WriteLine(html2);
Debug.WriteLine("----");
Debug.WriteLine(html3);
Debug.WriteLine("----");