Go

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

    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 := chilkat.NewGlobal()
    glob.SetMaxThreads(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.
    glob.SetThreadPoolLogPath("/home/users/chilkat/logs/threadPoolLog.txt")

    http1 := chilkat.NewHttp()
    http2 := chilkat.NewHttp()
    http3 := chilkat.NewHttp()

    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.
    c := make(chan *chilkat.Task)
    go http1.QuickGetStrAsync(url1,c)
    task1 := <-c
    if http1.LastMethodSuccess() == false {
        fmt.Println(http1.LastErrorText())
        glob.DisposeGlobal()
        http1.DisposeHttp()
        http2.DisposeHttp()
        http3.DisposeHttp()
        task1.DisposeTask()
        return
    }

    c := make(chan *chilkat.Task)
    go http2.QuickGetStrAsync(url2,c)
    task2 := <-c
    if http2.LastMethodSuccess() == false {
        fmt.Println(http2.LastErrorText())
        task1.DisposeTask()
        glob.DisposeGlobal()
        http1.DisposeHttp()
        http2.DisposeHttp()
        http3.DisposeHttp()
        task1.DisposeTask()
        task2.DisposeTask()
        return
    }

    c := make(chan *chilkat.Task)
    go http3.QuickGetStrAsync(url3,c)
    task3 := <-c
    if http3.LastMethodSuccess() == false {
        fmt.Println(http3.LastErrorText())
        task1.DisposeTask()
        task2.DisposeTask()
        glob.DisposeGlobal()
        http1.DisposeHttp()
        http2.DisposeHttp()
        http3.DisposeHttp()
        task1.DisposeTask()
        task2.DisposeTask()
        task3.DisposeTask()
        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.

    // Assuming success for brevity...

    // 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"
    var html1 *string = new(string)
    *html1 = err
    var html2 *string = new(string)
    *html2 = err
    var html3 *string = new(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()
    }

    fmt.Println(*html1)
    fmt.Println("----")
    fmt.Println(*html2)
    fmt.Println("----")
    fmt.Println(*html3)
    fmt.Println("----")

    task1.DisposeTask()
    task2.DisposeTask()
    task3.DisposeTask()

    glob.DisposeGlobal()
    http1.DisposeHttp()
    http2.DisposeHttp()
    http3.DisposeHttp()
    task1.DisposeTask()
    task2.DisposeTask()
    task3.DisposeTask()