We have implemented this necessary functionality in our java source base and would like the java team to push it (or a similar function) into the real source. This function is
necessary for program like holosketch which need to maintain more control over the
java threads than is currently possible.

The function below is very simple and is based on two functions already in threads_md.c:
sysThreadSuspend and sysThreadResume. The reason we needed this is that we wanted
a thread to be able to suspend itself and pass control to another specified thread. This
saves complexity and context-swapping over the other method of having one parent
do all of the work. The way we use this function is by having a single queue of java
threads (which we have to run serially because of our particular application). Each thread
runs itself until such time as it decides it's time to quit. It then calls this routine to
suspend itself and give control to the next thread in the queue. We've been using this
function with holosketch for the past several weeks with no problems.

Here is our function. Please feel free to change the function name as appropriate. Any
other modifications to the function can be done as necessary, as long as the basic
functionality of being able to suspend and resume from a single thread exists.


sysThreadSuspendSelfResumeOther(sys_thread_t *otherThread)
{
    sys_thread_t *self = sysThreadSelf();
 
    SCHED_LOCK();
 
    /* Our suspend of ourselves */
    self->state = SUSPENDED;
 
    if (! getcontext(&(CONTEXT(self)->ucontext))) {
        CONTEXT(self)->unix_errno = errno;
 
        if (otherThread->state == SUSPENDED) {
            otherThread->state = RUNNABLE;
            queueInsert(&runnable_queue, otherThread);
        }
        reschedule(SYNCHRONOUS); /* Go run the next thread */
 
        /* NOT REACHED */
    }
 
    /* We get here when we are re-awakened */
    SCHED_UNLOCK();
    return; /* yes Virginia, we do eventually return to here */
 }