org.jruby.internal.runtime

Class FutureThread

java.lang.Object

org.jruby.internal.runtime.FutureThread

All Implemented Interfaces:

ThreadLike

public class FutureThread
extends java.lang.Object
implements ThreadLike

Field Summary

Fields

Modifier and Type	Field and Description
private java.util.concurrent.Future	future
private java.lang.Thread	nativeThread
RubyThread	rubyThread
private ThreadedRunnable	runnable

Constructor Summary

Constructors

Constructor and Description
FutureThread(RubyThread rubyThread, ThreadedRunnable runnable)

Method Summary

Modifier and Type	Method and Description
java.util.concurrent.Future	getFuture()
int	getPriority() The current priority of the thread associated with this future.
void	interrupt() In order to do a thread interrupt, we need to get the actual thread, stored in the RubyRunnable instance and tell it to interrupt.
boolean	isAlive() If the future has not yet run and or is running and not yet complete.
boolean	isCurrent()
boolean	isInterrupted()
void	join()
void	join(long millis) We check for zero millis here because Future appears to wait for zero if you pass it zero, where Thread behavior is to wait forever.
java.lang.Thread	nativeThread()
void	setPriority(int priority) Set the priority of the thread associated with this future.
void	start() Starting a new thread in terms of a thread pool is just submitting it as a job to the pool.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

future

private volatile java.util.concurrent.Future future

nativeThread

private volatile java.lang.Thread nativeThread

runnable

private ThreadedRunnable runnable

rubyThread

public RubyThread rubyThread

Constructor Detail

FutureThread

public FutureThread(RubyThread rubyThread,
                    ThreadedRunnable runnable)

Method Detail

getFuture

public java.util.concurrent.Future getFuture()

start

public void start()

Starting a new thread in terms of a thread pool is just submitting it as a job to the pool.

Specified by:

start in interface ThreadLike

interrupt

public void interrupt()

In order to do a thread interrupt, we need to get the actual thread, stored in the RubyRunnable instance and tell it to interrupt. Future does not provide a mechanism for passing an interrupt to the thread running it. If the runnable is not being executed by a thread (not yet, or already done) do nothing.

Specified by:

interrupt in interface ThreadLike

isAlive

public boolean isAlive()

If the future has not yet run and or is running and not yet complete. We defined "alive" for a FutureThread to be the following:

The Runnable has not yet been submitted to the Executor. This is equivalent to a Ruby thread that has not yet been scheduled to run. Because Ruby considered a thread alive immediately, a FutureThread with no Future yet is still considered alive, because it will eventually be submitted. The Runnable has been submitted to the Executor but no Future has been returned yet. There's a bit of a race here if we expect future to not be null, since the runnable could be submitted to the Executor and complete execution before the future is ever assigned. This manifested as Thread.current.status from within a thread coming up as false... because isAlive returned false if the future was still null. The Runnable has been submitted to the Executor, the Future has been assigned, but the Future is not "done" yet. The thread is running, and we report it is alive. All other cases are considered "not alive" and we return fals here.

Specified by:

isAlive in interface ThreadLike

join

public void join()
          throws java.lang.InterruptedException,
                 java.util.concurrent.ExecutionException

Specified by:

join in interface ThreadLike

Throws:

java.lang.InterruptedException

java.util.concurrent.ExecutionException

join

public void join(long millis)
          throws java.lang.InterruptedException,
                 java.util.concurrent.ExecutionException

We check for zero millis here because Future appears to wait for zero if you pass it zero, where Thread behavior is to wait forever. We also catch and swallow CancellationException because it means the Future was cancelled before it ran, and is therefore as done as it will ever be.

Specified by:

join in interface ThreadLike

Parameters:

millis - The number of millis to wait; 0 waits forever.

Throws:

java.lang.InterruptedException - If the blocking join is interrupted by another thread.

java.util.concurrent.ExecutionException - If an execution error is raised by the underlying Future.

getPriority

public int getPriority()

The current priority of the thread associated with this future.

Specified by:

getPriority in interface ThreadLike

Returns:

the current priority of the thread in which we this is running

setPriority

public void setPriority(int priority)

Set the priority of the thread associated with this future.

Specified by:

setPriority in interface ThreadLike

Parameters:

priority - the new priority

isCurrent

public boolean isCurrent()

Specified by:

isCurrent in interface ThreadLike

isInterrupted

public boolean isInterrupted()

Specified by:

isInterrupted in interface ThreadLike

nativeThread

public java.lang.Thread nativeThread()

Specified by:

nativeThread in interface ThreadLike