PowerBuilder

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

integer li_rc
integer li_Success
oleobject loo_Glob
oleobject loo_Http1
oleobject loo_Http2
oleobject loo_Http3
string ls_Url1
string ls_Url2
string ls_Url3
oleobject loo_Task1
oleobject loo_Task2
oleobject loo_Task3
integer li_MaxWaitMs
string ls_Err
string ls_Html1
string ls_Html2
string ls_Html3

li_Success = 0

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

li_Success = 0

// 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. 
loo_Glob = create oleobject
li_rc = loo_Glob.ConnectToNewObject("Chilkat.Global")
if li_rc < 0 then
    destroy loo_Glob
    MessageBox("Error","Connecting to COM object failed")
    return
end if
loo_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.
loo_Glob.ThreadPoolLogPath = "/home/users/chilkat/logs/threadPoolLog.txt"

loo_Http1 = create oleobject
li_rc = loo_Http1.ConnectToNewObject("Chilkat.Http")

loo_Http2 = create oleobject
li_rc = loo_Http2.ConnectToNewObject("Chilkat.Http")

loo_Http3 = create oleobject
li_rc = loo_Http3.ConnectToNewObject("Chilkat.Http")

ls_Url1 = "http://www.marcusmiller.com/"
ls_Url2 = "http://www.tromboneshorty.com/"
ls_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.
loo_Task1 = loo_Http1.QuickGetStrAsync(ls_Url1)
if loo_Http1.LastMethodSuccess = 0 then
    Write-Debug loo_Http1.LastErrorText
    destroy loo_Glob
    destroy loo_Http1
    destroy loo_Http2
    destroy loo_Http3
    return
end if

loo_Task2 = loo_Http2.QuickGetStrAsync(ls_Url2)
if loo_Http2.LastMethodSuccess = 0 then
    Write-Debug loo_Http2.LastErrorText
    destroy loo_Task1
    destroy loo_Glob
    destroy loo_Http1
    destroy loo_Http2
    destroy loo_Http3
    return
end if

loo_Task3 = loo_Http3.QuickGetStrAsync(ls_Url3)
if loo_Http3.LastMethodSuccess = 0 then
    Write-Debug loo_Http3.LastErrorText
    destroy loo_Task1
    destroy loo_Task2
    destroy loo_Glob
    destroy loo_Http1
    destroy loo_Http2
    destroy loo_Http3
    return
end if

// 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.
li_Success = loo_Task1.Run()
// Assuming success for brevity...
li_Success = loo_Task2.Run()
li_Success = loo_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.
li_MaxWaitMs = 20000
li_Success = loo_Task1.Wait(li_MaxWaitMs)
li_Success = loo_Task2.Wait(li_MaxWaitMs)
li_Success = loo_Task3.Wait(li_MaxWaitMs)
// Assuming success for brevity...

ls_Err = "Task failed or canceled"
ls_Html1 = ls_Err
ls_Html2 = ls_Err
ls_Html3 = ls_Err

// Now get the HTML downloaded in each task:
if (loo_Task1.StatusInt = 7) AND (loo_Task1.TaskSuccess = 1) then
    ls_Html1 = loo_Task1.GetResultString()
end if

if (loo_Task2.StatusInt = 7) AND (loo_Task2.TaskSuccess = 1) then
    ls_Html2 = loo_Task2.GetResultString()
end if

if (loo_Task3.StatusInt = 7) AND (loo_Task3.TaskSuccess = 1) then
    ls_Html3 = loo_Task3.GetResultString()
end if

Write-Debug ls_Html1
Write-Debug "----"
Write-Debug ls_Html2
Write-Debug "----"
Write-Debug ls_Html3
Write-Debug "----"

destroy loo_Task1
destroy loo_Task2
destroy loo_Task3


destroy loo_Glob
destroy loo_Http1
destroy loo_Http2
destroy loo_Http3