Myna. Thread

Myna.Thread=function( f, args, priority )

Constructor function for Thread class

Parameters

Detail

Executes f in a separate thread.  This can be used to take advantage of multiple processors be splitting a long running task into multiple functions running in parallel, or to execute non-interactive code in the background.

Each Thread runs in a separate Myna request with it’s own global ($) variables.  Because the script path is copied from the parent thread, $application will be created the same as the parent thread and $application.onRequestStart() .onError() etc. will be fired at the appropriate times.  This means that you should never call Myna.Thread from an application.sjs file, or your code will create an infinite thread spawning loop, and will error out after 5 levels.

You can pass variables from the current thread into Myna.Thread and the sub-thread will have access to them even after the parent thread exits

The parent thread can access the return value from f via Myna.Thread.getReturnValue or from Myna.Thread.join

The parent thread can access the generated output of f via Myna.Thread.getContent

Warning

Threads can themselves call Threads to a maximum depth of 5 levels.  This prevents infinite Thread spawning.

Memory Tip

if you do not need access to the subThread’s output, you can dramatically decrease memory usage by setting Thread.mynaThread to null

Performance Tip

If you are running Myna.Thread in a loop, you can limit the number of concurrent Threads by making periodic calls to Myna.Thread.joinAll.  See examples below

Returns

Reference to Thread instance

Examples

// ----- send an email in the background with  a very low priority ---------
var t= new Myna.Thread(function(data){
    new Myna.Mail({
        to:data.toAddress,
        from:data.fromAddress,
        ...
    }).send()
},[$req.data],-90)


// ----- run all your queries at once --------------------------------------
new Myna.Thread(function(){
    return new Myna.Query({
        ds:"some ds",
        sql:"..."
    }).data
}])

new Myna.Thread(function(){
    return new Myna.Query({
        ds:"some other ds",
        sql:"..."
    }).data
})

// a destructuring assignment takes each row from the array returned from
// joinAll and assigns them to the variables in the assignment array
var [ qryData1, qryData2] = Myna.Thread.joinAll();


// ----- break up a memory intensive task into  ----------------------------
// ----- a set number of concurrent threads     ----------------------------
qry.data.forEach(function(row,index,array){
    var t=new Myna.Thread(function(){
        ... bunch of work ...
    },[])

    //this frees each thread's memory when that thread is joined
    t.releaseOnJoin=true;

    //this stops after every three spawns or the end of the loop to
    //wait for running threads to finish
    if ((index+1)%3 == 0  || index == array.length-1) Myna.Thread.joinAll();
})

Myna.Thread.prototype.join=function( timeout, throwOnTimeout )

Pauses the current thread until this thread exits, and then returns thread function result

Returns

return value of thread function

Parameters

Myna.Thread.prototype.releaseSubThread=function()

releases this Thread’s subThread so that its memory can be recovered

Detail

This function sets Thread.mynaThread to null.  If Thread.captureOutput is true, this function will first cache the subThread’s return value and generated content.  If you call this function a second time after setting Thread.captureOutput to false, then any cached values will be cleared

Myna.Thread.prototype.isRunning=function()

returns true if this thread is still running

Myna.Thread.prototype.getContent=function()

returns content generated by this thread

Don’t expect to see anything while isRunning returns true

Myna.Thread.prototype.getReturnValue=function()

returns the value returned by the thread function.

Don’t expect to see anything while isRunning returns true

Myna.Thread.prototype.stop=function()

stops this thread.

Myna.Thread.prototype.kill=function()

kills this thread.

Myna.Thread.joinAll = function( timeout, throwOnTimeout, killOnTimeout )

Static function that calls join on all threads spawned from the current thread, and returns an array of their return values

Parameters

(10).times(function(i){
    new Myna.Thread(function(i){
        return i;
    },[i])
})
Myna.printDump(Myna.Thread.joinAll())

Myna.Thread.getThreadArray = function()

Static function that returns an array of all the threads spawned in the current thread

Myna.ThreadGroup=function( options )

Constructor function for ThreadGroup class

Parameters

Options

Examples

// ----- send several emails in the background with  a very low priority ---------
var tg= new Myna.ThreadGroup({
    priority:-90,
    releaseOnJoin:true,
    captureOutput:false,
    fn:function(data){
        new Myna.Mail({
            to:data.toAddress,
            from:data.fromAddress,
            ...
        }).send()
    }

})

qry.data.forEach(function(row){
    tg.spawn(row);
})

// ----- run all your queries at once --------------------------------------
var queries= new Myna.ThreadGroup({
    releaseOnJoin:true
})

qry.data.forEach(function(row){
    tg.spawn(row);
})
tg.add(function(){
    return new Myna.Query({
        ds:"some ds",
        sql:"..."
    }).data
}])

tg.add(function(){
    return new Myna.Query({
        ds:"some other ds",
        sql:"..."
    }).data
})

// a destructuring assignment takes each row from the array returned from
// joinAll and assigns them to the variables in the assignment array
var [ qryData1, qryData2] = tg.join();


// ----- break up a memory intensive task into  ----------------------------
// ----- a set number of concurrent threads     ----------------------------
var workers= new Myna.ThreadGroup({
    releaseOnJoin:true,
    fn:function(row){
        ... bunch of work ...
    },
    joinEvery:3
})
qry.data.forEach(function(row,index,array){
    workers.spawn(row);
})

var result = workers.join();

Myna.ThreadGroup.prototype.getThreadArray=function()

returns an array of all the threads spawned by this group

join all the threads in this group.

Takes the same parameters as Myna.Thread.joinAll

Myna.ThreadGroup.prototype.spawn=function()

calls ThreadGroup.add using this this group’s defaults and returns the generated thread.

<ThreadGroup.fn> must be defined.  Any arguments passed to this function will be passed to the generated thread

Myna.ThreadGroup.prototype.getRunningThreads=function()

returns an array of the threads in this ThreadGroup that are still running

Myna.ThreadGroup.prototype.add=function( func, args, priority )

creates a thread, adds it to this group, and returns the generated thread

Parameters