AutoIt

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

Local $bSuccess = False

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

$bSuccess = 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. 
$oGlob = ObjCreate("Chilkat.Global")
$oGlob.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.
$oGlob.ThreadPoolLogPath = "/home/users/chilkat/logs/threadPoolLog.txt"

$oHttp1 = ObjCreate("Chilkat.Http")
$oHttp2 = ObjCreate("Chilkat.Http")
$oHttp3 = ObjCreate("Chilkat.Http")

Local $sUrl1 = "http://www.marcusmiller.com/"
Local $sUrl2 = "http://www.tromboneshorty.com/"
Local $sUrl3 = "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.
Local $oTask1 = $oHttp1.QuickGetStrAsync($sUrl1)
If ($oHttp1.LastMethodSuccess = False) Then
    ConsoleWrite($oHttp1.LastErrorText & @CRLF)
    Exit
EndIf

Local $oTask2 = $oHttp2.QuickGetStrAsync($sUrl2)
If ($oHttp2.LastMethodSuccess = False) Then
    ConsoleWrite($oHttp2.LastErrorText & @CRLF)

    Exit
EndIf

Local $oTask3 = $oHttp3.QuickGetStrAsync($sUrl3)
If ($oHttp3.LastMethodSuccess = False) Then
    ConsoleWrite($oHttp3.LastErrorText & @CRLF)

    Exit
EndIf

; 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.
$bSuccess = $oTask1.Run()
; Assuming success for brevity...
$bSuccess = $oTask2.Run()
$bSuccess = $oTask3.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.
Local $iMaxWaitMs = 20000
$bSuccess = $oTask1.Wait($iMaxWaitMs)
$bSuccess = $oTask2.Wait($iMaxWaitMs)
$bSuccess = $oTask3.Wait($iMaxWaitMs)
; Assuming success for brevity...

Local $sErr = "Task failed or canceled"
Local $sHtml1 = $sErr
Local $sHtml2 = $sErr
Local $sHtml3 = $sErr

; Now get the HTML downloaded in each task:
If (($oTask1.StatusInt = 7) And ($oTask1.TaskSuccess = True)) Then
    $sHtml1 = $oTask1.GetResultString()
EndIf

If (($oTask2.StatusInt = 7) And ($oTask2.TaskSuccess = True)) Then
    $sHtml2 = $oTask2.GetResultString()
EndIf

If (($oTask3.StatusInt = 7) And ($oTask3.TaskSuccess = True)) Then
    $sHtml3 = $oTask3.GetResultString()
EndIf

ConsoleWrite($sHtml1 & @CRLF)
ConsoleWrite("----" & @CRLF)
ConsoleWrite($sHtml2 & @CRLF)
ConsoleWrite("----" & @CRLF)
ConsoleWrite($sHtml3 & @CRLF)
ConsoleWrite("----" & @CRLF)