C

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. C

#include <C_CkGlobal.h>
#include <C_CkHttp.h>
#include <C_CkTask.h>

void ChilkatSample(void)
    {
    BOOL success;
    HCkGlobal glob;
    HCkHttp http1;
    HCkHttp http2;
    HCkHttp http3;
    const char *url1;
    const char *url2;
    const char *url3;
    HCkTask task1;
    HCkTask task2;
    HCkTask task3;
    int maxWaitMs;
    const char *err;
    const char *html1;
    const char *html2;
    const char *html3;

    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 = CkGlobal_Create();
    CkGlobal_putMaxThreads(glob,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(glob,"/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) {
        printf("%s\n",CkHttp_lastErrorText(http1));
        CkGlobal_Dispose(glob);
        CkHttp_Dispose(http1);
        CkHttp_Dispose(http2);
        CkHttp_Dispose(http3);
        return;
    }

    task2 = CkHttp_QuickGetStrAsync(http2,url2);
    if (CkHttp_getLastMethodSuccess(http2) == FALSE) {
        printf("%s\n",CkHttp_lastErrorText(http2));
        CkTask_Dispose(task1);
        CkGlobal_Dispose(glob);
        CkHttp_Dispose(http1);
        CkHttp_Dispose(http2);
        CkHttp_Dispose(http3);
        return;
    }

    task3 = CkHttp_QuickGetStrAsync(http3,url3);
    if (CkHttp_getLastMethodSuccess(http3) == FALSE) {
        printf("%s\n",CkHttp_lastErrorText(http3));
        CkTask_Dispose(task1);
        CkTask_Dispose(task2);
        CkGlobal_Dispose(glob);
        CkHttp_Dispose(http1);
        CkHttp_Dispose(http2);
        CkHttp_Dispose(http3);
        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 = 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) && (CkTask_getTaskSuccess(task1) == TRUE)) {
        html1 = CkTask_getResultString(task1);
    }

    if ((CkTask_getStatusInt(task2) == 7) && (CkTask_getTaskSuccess(task2) == TRUE)) {
        html2 = CkTask_getResultString(task2);
    }

    if ((CkTask_getStatusInt(task3) == 7) && (CkTask_getTaskSuccess(task3) == TRUE)) {
        html3 = CkTask_getResultString(task3);
    }

    printf("%s\n",html1);
    printf("----\n");
    printf("%s\n",html2);
    printf("----\n");
    printf("%s\n",html3);
    printf("----\n");

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


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

    }