RubyThread

java.lang.Object
- org.jruby.RubyBasicObject
- - org.jruby.RubyObject
  - - org.jruby.RubyThread

All Implemented Interfaces:

java.io.Serializable, java.lang.Cloneable, java.lang.Comparable<IRubyObject>, InstanceVariables, InternalVariables, IRubyObject, ExecutionContext, CoreObjectType
```
public class RubyThread
extends RubyObject
implements ExecutionContext
```
Implementation of Ruby's Thread class. Each Ruby thread is mapped to an underlying Java Virtual Machine thread.
Thread encapsulates the behavior of a thread of execution, including the main thread of the Ruby script. In the descriptions that follow, the parameter aSymbol refers to a symbol, which is either a quoted string or a Symbol (such as :name). Note: For CVS history, see ThreadClass.java.

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`RubyThread.BlockingTask`
`static class`	`RubyThread.Location`
`static class`	`RubyThread.SleepTask`
`static class`	`RubyThread.Status` Thread statuses

Nested classes/interfaces inherited from class org.jruby.RubyObject
RubyObject.Data

Nested classes/interfaces inherited from class org.jruby.RubyBasicObject
RubyBasicObject.Finalizer

Field Summary

Fields
Modifier and Type	Field and Description
`private boolean`	`abortOnException` Whether this thread should try to abort the program on exception
`private BlockingIO.Condition`	`blockingIO`
`private java.lang.ref.WeakReference<ThreadContext>`	`contextRef` Weak reference to the ThreadContext for this thread.
`private java.util.Map<java.lang.Object,IRubyObject>`	`contextVariables` Context-local variables, internal-ish thread locals
`private RubyThread.BlockingTask`	`currentBlockingTask` The current task blocking a thread, to allow interrupting it in an appropriate way
`private java.nio.channels.Selector`	`currentSelector`
`private static boolean`	`DEBUG`
`private boolean`	`disposed` Whether or not this thread has been disposed of
`private IRubyObject`	`errorInfo` Per-thread "current exception"
`private RaiseException`	`exitingException` The exception currently being raised out of the thread.
`private IRubyObject`	`finalResult` The final value resulting from the thread's execution
`private java.util.List<java.util.concurrent.locks.Lock>`	`heldLocks` The list of locks this thread currently holds, so they can be released on exit
`private int`	`initialPriority` The thread's initial priority, for use in thread pooled mode
`private static Logger`	`LOG`
`private java.util.concurrent.atomic.AtomicReference<ThreadService.Event>`	`mail` Mail slot for cross-thread events
`private int`	`RUBY_MAX_THREAD_PRIORITY`
`private int`	`RUBY_MIN_THREAD_PRIORITY`
`private java.util.concurrent.atomic.AtomicReference<RubyThread.Status>`	`status` Current status in an atomic reference
`private RubyThreadGroup`	`threadGroup` The ThreadGroup to which this thread belongs
`private ThreadLike`	`threadImpl` The thread-like think that is actually executing
`private java.util.Map<IRubyObject,IRubyObject>`	`threadLocalVariables` Normal thread-local variables

Fields inherited from class org.jruby.RubyObject
FIELD_ALLOCATED_CLASSES, FIELD_ALLOCATORS, IVAR_INSPECTING_OBJECT_ALLOCATOR, OBJECT_ALLOCATOR, OBJECT_VAR0_ALLOCATOR, OBJECT_VAR1_ALLOCATOR, OBJECT_VAR2_ALLOCATOR, OBJECT_VAR3_ALLOCATOR, OBJECT_VAR4_ALLOCATOR, OBJECT_VAR5_ALLOCATOR, OBJECT_VAR6_ALLOCATOR, OBJECT_VAR7_ALLOCATOR, OBJECT_VAR8_ALLOCATOR, OBJECT_VAR9_ALLOCATOR, REIFYING_OBJECT_ALLOCATOR

Fields inherited from class org.jruby.RubyBasicObject
ALL_F, BASICOBJECT_ALLOCATOR, COMPARE_BY_IDENTITY_F, ERR_INSECURE_SET_INST_VAR, FALSE_F, FL_USHIFT, flags, FROZEN_F, metaClass, NEVER, NIL_F, STAMP_OFFSET, TAINTED_F, UNDEF, UNTRUSTED_F, USER0_F, USER1_F, USER2_F, USER3_F, USER4_F, USER5_F, USER6_F, USER7_F, USER8_F, VAR_TABLE_OFFSET, varTable, varTableStamp

Fields inherited from interface org.jruby.runtime.builtin.IRubyObject
NULL_ARRAY

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`RubyThread(Ruby runtime, RubyClass type)`
	`RubyThread(Ruby runtime, RubyClass klass, ThreadedRunnable runnable)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static IRubyObject`	`abort_on_exception_set_x(IRubyObject recv, IRubyObject value)`
`IRubyObject`	`abort_on_exception_set(IRubyObject val)`
`static RubyBoolean`	`abort_on_exception_x(IRubyObject recv)` Returns the status of the global ``abort on exception'' condition.
`RubyBoolean`	`abort_on_exception()`
`private boolean`	`abortOnException(Ruby runtime)`
`private void`	`addToCorrectThreadGroup(ThreadContext context)`
`static RubyThread`	`adopt(IRubyObject recv, java.lang.Thread t)`
`private static RubyThread`	`adoptThread(IRubyObject recv, java.lang.Thread t, Block block)`
`void`	`afterBlockingCall()`
`RubyBoolean`	`alive_p()`
`IRubyObject`	`backtrace_locations(ThreadContext context, IRubyObject[] args)`
`IRubyObject`	`backtrace(ThreadContext context)`
`IRubyObject`	`backtrace20(ThreadContext context, IRubyObject[] args)`
`void`	`beDead()`
`void`	`beforeBlockingCall()`
`void`	`beforeStart()` Perform pre-execution tasks once the native thread is running, but we have not yet called the Ruby code for the thread.
`void`	`checkMail(ThreadContext context)`
`void`	`cleanTerminate(IRubyObject result)`
`private void`	`clearThreadLocals()`
`static RubyClass`	`createThreadClass(Ruby runtime)`
`static IRubyObject`	`critical_set(IRubyObject receiver, IRubyObject value)`
`static IRubyObject`	`critical(IRubyObject receiver)`
`static RubyThread`	`current(IRubyObject recv)`
`private static void`	`debug(RubyThread thread, java.lang.String message)`
`void`	`dieFromFinalizer()` Used for finalizers that need to kill a Ruby thread.
`void`	`dispose()` Dispose of the current thread by tidying up connections to other stuff
`void`	`enterSleep()`
`boolean`	`equals(java.lang.Object obj)` This method is just a wrapper around the Ruby "==" method, provided so that RubyObjects can be used as keys in the Java HashMap object underlying RubyHash.
`void`	`exceptionRaised(RaiseException exception)`
`void`	`exceptionRaised(java.lang.Throwable exception)` For handling all non-Ruby exceptions bubbling out of threads
`void`	`executeBlockingTask(RubyThread.BlockingTask task)`
`static IRubyObject`	`exit(IRubyObject receiver, Block block)`
`void`	`exitSleep()`
`ThreadContext`	`getContext()`
`java.util.Map<java.lang.Object,IRubyObject>`	`getContextVariables()`
`IRubyObject`	`getErrorInfo()`
`java.lang.Thread`	`getNativeThread()`
`private java.nio.channels.Selector`	`getSelector(java.nio.channels.SelectableChannel channel)`
`private IRubyObject`	`getSymbolKey(IRubyObject originalKey)`
`RubyThreadGroup`	`getThreadGroup()`
`private java.util.Map<IRubyObject,IRubyObject>`	`getThreadLocals()`
`IRubyObject`	`group()`
`int`	`hashCode()` Override the Object#hashCode method to make sure that the Ruby hash is actually used as the hashcode for Ruby objects.
`private java.lang.String`	`identityString()`
`IRubyObject`	`initialize(ThreadContext context, IRubyObject[] args, Block block)`
`IRubyObject`	`inspect()` rb_obj_inspect call-seq: obj.inspect => string Returns a string containing a human-readable representation of obj.
`void`	`internalRaise(IRubyObject[] args)` This is intended to be used to raise exceptions in Ruby threads from non- Ruby threads like Timeout's thread.
`void`	`interrupt()`
`boolean`	`isAlive()`
`private boolean`	`isCurrent()`
`java.lang.StackTraceElement[]`	`javaBacktrace()`
`private int`	`javaPriorityToRubyPriority(int javaPriority)`
`IRubyObject`	`join(IRubyObject[] args)`
`RubyBoolean`	`key_p(IRubyObject key)`
`RubyArray`	`keys()`
`IRubyObject`	`kill_bang()`
`IRubyObject`	`kill()`
`static IRubyObject`	`kill(IRubyObject receiver, IRubyObject rubyThread, Block block)`
`static RubyArray`	`list(IRubyObject recv)`
`void`	`lock(java.util.concurrent.locks.Lock lock)` Acquire the given lock, holding a reference to it for cleanup on thread termination.
`void`	`lockInterruptibly(java.util.concurrent.locks.Lock lock)` Acquire the given lock interruptibly, holding a reference to it for cleanup on thread termination.
`static RubyThread`	`main(IRubyObject recv)`
`static RubyThread`	`mainThread(IRubyObject receiver)`
`static IRubyObject`	`newInstance(IRubyObject recv, IRubyObject[] args, Block block)` `Thread.new`
`IRubyObject`	`op_aref(IRubyObject key)`
`IRubyObject`	`op_aset(IRubyObject key, IRubyObject value)`
`static IRubyObject`	`pass(IRubyObject recv)`
`void`	`pollThreadEvents()`
`void`	`pollThreadEvents(ThreadContext context)`
`private IRubyObject`	`prepareRaiseException(Ruby runtime, IRubyObject[] args, Block block)`
`IRubyObject`	`priority_set(IRubyObject priority)`
`RubyFixnum`	`priority()`
`IRubyObject`	`raise(IRubyObject exception)` Simplified utility method for just raising an existing exception in this thread.
`IRubyObject`	`raise(IRubyObject[] args, Block block)`
`private void`	`receivedAnException(ThreadContext context, IRubyObject exception)`
`void`	`receiveMail(ThreadService.Event event)`
`private int`	`rubyPriorityToJavaPriority(int rubyPriority)`
`IRubyObject`	`run()`
`IRubyObject`	`safe_level()`
`boolean`	`select(java.nio.channels.Channel channel, RubyIO io, int ops)`
`boolean`	`select(java.nio.channels.Channel channel, RubyIO io, int ops, long timeout)`
`boolean`	`select(RubyIO io, int ops)`
`boolean`	`select(RubyIO io, int ops, long timeout)`
`boolean`	`selectForAccept(RubyIO io)` Deprecated.
`void`	`setContext(ThreadContext context)`
`IRubyObject`	`setErrorInfo(IRubyObject errorInfo)`
`(package private) void`	`setThreadGroup(RubyThreadGroup rubyThreadGroup)`
`boolean`	`sleep(long millis)` We can never be sure if a wait will finish because of a Java "spurious wakeup".
`static RubyThread`	`start(IRubyObject recv, IRubyObject[] args, Block block)` Basically the same as Thread.new .
`static RubyThread`	`start19(IRubyObject recv, IRubyObject[] args, Block block)`
`private static RubyThread`	`startThread(IRubyObject recv, IRubyObject[] args, boolean callInit, Block block)`
`private IRubyObject`	`startWith(ThreadedRunnable runnable)`
`IRubyObject`	`status()`
`private IRubyObject`	`status(Ruby runtime)`
`IRubyObject`	`status(ThreadContext context)`
`RubyBoolean`	`stop_p()`
`static IRubyObject`	`stop(ThreadContext context, IRubyObject receiver)`
`private static void`	`throwThreadKill()`
`java.lang.String`	`toString()` The default toString method is just a wrapper that calls the Ruby "to_s" method.
`boolean`	`tryLock(java.util.concurrent.locks.Lock lock)` Try to acquire the given lock, adding it to a list of held locks for cleanup on thread termination if it is acquired.
`void`	`unlock(java.util.concurrent.locks.Lock lock)` Release the given lock and remove it from the list of locks to be released on thread termination.
`void`	`unlockAll()` Release all locks held.
`IRubyObject`	`value()`
`boolean`	`wait_timeout(IRubyObject o, java.lang.Double timeout)`
`boolean`	`waitForIO(ThreadContext context, RubyIO io, int ops)`
`RubyThread`	`wakeup()`

Methods inherited from class org.jruby.RubyObject
attachToObjectSpace, callInit, callInit, callInit, callInit, callInit, callInit, callInit, callInit, callInit, callInit, convertToType, createObjectClass, eqlInternal, equalInternal, getNativeTypeIndex, initialize, initialize, inspect, op_eqq, puts, specificEval

Methods inherited from class org.jruby.RubyBasicObject
addFinalizer, anyToString, asJavaString, asString, callMethod, callMethod, callMethod, callMethod, callMethod, callMethod, callMethod, callMethod, callSuper, checkArrayType, checkCallMethod, checkFrozen, checkStringType, checkStringType19, compareTo, convertToArray, convertToFloat, convertToHash, convertToInteger, convertToInteger, convertToInteger, convertToString, copyInstanceVariablesInto, copySpecialInstanceVariables, createBasicObjectClass, dataGetStruct, dataGetStructChecked, dataWrapStruct, display, dup, ensureInstanceVariablesSettable, eql_p, eql, equal_p, equal_p19, evalUnder, extend, fastGetInstanceVariable, fastGetInternalVariable, fastHasInstanceVariable, fastHasInternalVariable, fastSetInstanceVariable, fastSetInternalVariable, freeze, frozen_p, getFFIHandle, getFlag, getInstanceEvalClass, getInstanceVariable, getInstanceVariableList, getInstanceVariableNameList, getInstanceVariables, getInternalVariable, getInternalVariables, getJavaClass, getMetaClass, getNativeHandle, getObjectId, getRuntime, getSingletonClass, getSingletonClassClone, getType, getVariable, getVariableCount, getVariableList, getVariableNameList, hash, hashyInspect, hasInstanceVariable, hasInternalVariable, hasVariables, id_deprecated, id, infectBy, infectBy, infectBy, initialize_copy, initialize19, inspectHashCode, instance_eval, instance_eval, instance_eval, instance_eval, instance_eval19, instance_eval19, instance_eval19, instance_eval19, instance_exec, instance_exec19, instance_of_p, instance_variable_defined_p, instance_variable_get, instance_variable_set, instance_variables, instance_variables19, isBuiltin, isClass, isFalse, isFrozen, isImmediate, isModule, isNil, isTaint, isTrue, isUntrusted, kind_of_p, makeMetaClass, method_missing19, method, method19, methods, methods, methods19, nil_p, op_cmp, op_equal_19, op_equal, op_match, op_match19, op_not_equal, op_not_match, op_not, private_methods, private_methods19, protected_methods, protected_methods19, public_methods, public_methods19, rbClone, recacheBuiltinMethods, remove_instance_variable, removeFinalizers, removeInstanceVariable, removeInternalVariable, respond_to_p, respond_to_p, respond_to_p19, respond_to_p19, respondsTo, respondsToMissing, respondsToMissing, send, send, send, send, send, send19, send19, send19, send19, setFFIHandle, setFlag, setFrozen, setInstanceVariable, setInternalVariable, setMetaClass, setNativeHandle, setTaint, setUntrusted, setVariable, singleton_method_added19, singleton_method_removed19, singleton_method_undefined19, singleton_methods, singleton_methods19, specificEval, specificEval, specificEval, specificEval, syncVariables, syncVariables, taint, taint, tainted_p, testFrozen, testFrozen, to_a, to_s, toJava, trust, type_deprecated, type, untaint, untrust, untrusted_p, validateInstanceVariable, variableTableContains, variableTableFastContains, variableTableFastFetch, variableTableFastStore, variableTableFetch, variableTableRemove, variableTableStore, variableTableSync, yieldUnder, yieldUnder

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail
- LOG
```
private static final Logger LOG
```
- threadImpl
```
private ThreadLike threadImpl
```
  The thread-like think that is actually executing
- threadLocalVariables
```
private transient java.util.Map<IRubyObject,IRubyObject> threadLocalVariables
```
  Normal thread-local variables
- contextVariables
```
private final java.util.Map<java.lang.Object,IRubyObject> contextVariables
```
  Context-local variables, internal-ish thread locals
- abortOnException
```
private boolean abortOnException
```
  Whether this thread should try to abort the program on exception
- finalResult
```
private IRubyObject finalResult
```
  The final value resulting from the thread's execution
- exitingException
```
private RaiseException exitingException
```
  The exception currently being raised out of the thread. We reference it here to continue propagating it while handling thread shutdown logic and abort_on_exception.
- threadGroup
```
private RubyThreadGroup threadGroup
```
  The ThreadGroup to which this thread belongs
- errorInfo
```
private IRubyObject errorInfo
```
  Per-thread "current exception"
- contextRef
```
private volatile java.lang.ref.WeakReference<ThreadContext> contextRef
```
  Weak reference to the ThreadContext for this thread.
- DEBUG
```
private static final boolean DEBUG
```
  See Also:
  
  Constant Field Values
- RUBY_MIN_THREAD_PRIORITY
```
private int RUBY_MIN_THREAD_PRIORITY
```
- RUBY_MAX_THREAD_PRIORITY
```
private int RUBY_MAX_THREAD_PRIORITY
```
- status
```
private final java.util.concurrent.atomic.AtomicReference<RubyThread.Status> status
```
  Current status in an atomic reference
- mail
```
private final java.util.concurrent.atomic.AtomicReference<ThreadService.Event> mail
```
  Mail slot for cross-thread events
- currentBlockingTask
```
private volatile RubyThread.BlockingTask currentBlockingTask
```
  The current task blocking a thread, to allow interrupting it in an appropriate way
- heldLocks
```
private final java.util.List<java.util.concurrent.locks.Lock> heldLocks
```
  The list of locks this thread currently holds, so they can be released on exit
- disposed
```
private volatile boolean disposed
```
  Whether or not this thread has been disposed of
- initialPriority
```
private int initialPriority
```
  The thread's initial priority, for use in thread pooled mode
- currentSelector
```
private volatile java.nio.channels.Selector currentSelector
```
- blockingIO
```
private volatile BlockingIO.Condition blockingIO
```

Constructor Detail

RubyThread

protected RubyThread(Ruby runtime,
                     RubyClass type)

RubyThread

public RubyThread(Ruby runtime,
                  RubyClass klass,
                  ThreadedRunnable runnable)

Method Detail

receiveMail

public void receiveMail(ThreadService.Event event)

checkMail

public void checkMail(ThreadContext context)

getErrorInfo
```
public IRubyObject getErrorInfo()
```

setErrorInfo

public IRubyObject setErrorInfo(IRubyObject errorInfo)

setContext

public void setContext(ThreadContext context)

getContext
```
public ThreadContext getContext()
```

getNativeThread

public java.lang.Thread getNativeThread()

beforeStart
```
public void beforeStart()
```
Perform pre-execution tasks once the native thread is running, but we have not yet called the Ruby code for the thread.

dispose
```
public void dispose()
```
Dispose of the current thread by tidying up connections to other stuff

createThreadClass

public static RubyClass createThreadClass(Ruby runtime)

newInstance

public static IRubyObject newInstance(IRubyObject recv,
                                      IRubyObject[] args,
                                      Block block)

Thread.new

Thread.new( [ arg ]* ) {| args | block } -> aThread

Creates a new thread to execute the instructions given in block, and begins running it. Any arguments passed to Thread.new are passed into the block.

 x = Thread.new { sleep .1; print "x"; print "y"; print "z" }
 a = Thread.new { print "a"; print "b"; sleep .2; print "c" }
 x.join # Let the threads finish before
 a.join # main thread exits...

produces: abxyzc

start

public static RubyThread start(IRubyObject recv,
                               IRubyObject[] args,
                               Block block)

Basically the same as Thread.new . However, if class Thread is subclassed, then calling start in that subclass will not invoke the subclass's initialize method.

start19

public static RubyThread start19(IRubyObject recv,
                                 IRubyObject[] args,
                                 Block block)

adopt

public static RubyThread adopt(IRubyObject recv,
                               java.lang.Thread t)

adoptThread

private static RubyThread adoptThread(IRubyObject recv,
                                      java.lang.Thread t,
                                      Block block)

initialize

public IRubyObject initialize(ThreadContext context,
                              IRubyObject[] args,
                              Block block)

startWith

private IRubyObject startWith(ThreadedRunnable runnable)
                       throws RaiseException,
                              java.lang.OutOfMemoryError

Throws:: RaiseException; java.lang.OutOfMemoryError

startThread

private static RubyThread startThread(IRubyObject recv,
                                      IRubyObject[] args,
                                      boolean callInit,
                                      Block block)

cleanTerminate

public void cleanTerminate(IRubyObject result)

beDead
```
public void beDead()
```

pollThreadEvents
```
public void pollThreadEvents()
```

pollThreadEvents

public void pollThreadEvents(ThreadContext context)

throwThreadKill
```
private static void throwThreadKill()
```

abort_on_exception_x
```
public static RubyBoolean abort_on_exception_x(IRubyObject recv)
```
Returns the status of the global ``abort on exception'' condition. The default is false. When set to true, will cause all threads to abort (the process will exit(0)) if an exception is raised in any thread. See also Thread.abort_on_exception= .

abort_on_exception_set_x

public static IRubyObject abort_on_exception_set_x(IRubyObject recv,
                                                   IRubyObject value)

current

public static RubyThread current(IRubyObject recv)

main

public static RubyThread main(IRubyObject recv)

pass

public static IRubyObject pass(IRubyObject recv)

list

public static RubyArray list(IRubyObject recv)

addToCorrectThreadGroup

private void addToCorrectThreadGroup(ThreadContext context)

getSymbolKey

private IRubyObject getSymbolKey(IRubyObject originalKey)

getThreadLocals

private java.util.Map<IRubyObject,IRubyObject> getThreadLocals()

clearThreadLocals
```
private void clearThreadLocals()
```

getContextVariables

public final java.util.Map<java.lang.Object,IRubyObject> getContextVariables()

Specified by:: getContextVariables in interface ExecutionContext

isAlive
```
public boolean isAlive()
```

op_aref

public IRubyObject op_aref(IRubyObject key)

op_aset

public IRubyObject op_aset(IRubyObject key,
                           IRubyObject value)

abort_on_exception

public RubyBoolean abort_on_exception()

abort_on_exception_set

public IRubyObject abort_on_exception_set(IRubyObject val)

alive_p
```
public RubyBoolean alive_p()
```

join

public IRubyObject join(IRubyObject[] args)

value
```
public IRubyObject value()
```

group
```
public IRubyObject group()
```

setThreadGroup

void setThreadGroup(RubyThreadGroup rubyThreadGroup)

inspect
```
public IRubyObject inspect()
```
Description copied from class: RubyBasicObject

rb_obj_inspect call-seq: obj.inspect => string Returns a string containing a human-readable representation of obj. If not overridden, uses the to_s method to generate the string. [ 1, 2, 3..4, 'five' ].inspect #=> "[1, 2, 3..4, \"five\"]" Time.new.inspect #=> "Wed Apr 09 08:54:39 CDT 2003"

Specified by:

inspect in interface IRubyObject

Overrides:

inspect in class RubyBasicObject

Returns:

String

key_p

public RubyBoolean key_p(IRubyObject key)

keys
```
public RubyArray keys()
```

critical_set

public static IRubyObject critical_set(IRubyObject receiver,
                                       IRubyObject value)

critical

public static IRubyObject critical(IRubyObject receiver)

stop

public static IRubyObject stop(ThreadContext context,
                               IRubyObject receiver)

kill

public static IRubyObject kill(IRubyObject receiver,
                               IRubyObject rubyThread,
                               Block block)

exit

public static IRubyObject exit(IRubyObject receiver,
                               Block block)

stop_p
```
public RubyBoolean stop_p()
```

wakeup
```
public RubyThread wakeup()
```

priority
```
public RubyFixnum priority()
```

priority_set

public IRubyObject priority_set(IRubyObject priority)

javaPriorityToRubyPriority

private int javaPriorityToRubyPriority(int javaPriority)

rubyPriorityToJavaPriority

private int rubyPriorityToJavaPriority(int rubyPriority)

raise
```
public IRubyObject raise(IRubyObject exception)
```
Simplified utility method for just raising an existing exception in this thread.

Parameters:

exception - the exception to raise

Returns:

this thread

raise

public IRubyObject raise(IRubyObject[] args,
                         Block block)

internalRaise
```
public void internalRaise(IRubyObject[] args)
```
This is intended to be used to raise exceptions in Ruby threads from non- Ruby threads like Timeout's thread.

Parameters:

args - Same args as for Thread#raise

block - Same as for Thread#raise

prepareRaiseException

private IRubyObject prepareRaiseException(Ruby runtime,
                                          IRubyObject[] args,
                                          Block block)

run
```
public IRubyObject run()
```

sleep
```
public boolean sleep(long millis)
              throws java.lang.InterruptedException
```
We can never be sure if a wait will finish because of a Java "spurious wakeup". So if we explicitly wakeup and we wait less than requested amount we will return false. We will return true if we sleep right amount or less than right amount via spurious wakeup.

Throws:

java.lang.InterruptedException

status
```
public IRubyObject status()
```

status

public IRubyObject status(ThreadContext context)

status

private IRubyObject status(Ruby runtime)

executeBlockingTask

public void executeBlockingTask(RubyThread.BlockingTask task)
                         throws java.lang.InterruptedException

Throws:: java.lang.InterruptedException

enterSleep
```
public void enterSleep()
```

exitSleep
```
public void exitSleep()
```

kill
```
public IRubyObject kill()
```

dieFromFinalizer
```
public void dieFromFinalizer()
```
Used for finalizers that need to kill a Ruby thread. Finalizers run in a VM thread to which we do not want to attach a ThreadContext and within which we do not want to check for Ruby thread events. This mechanism goes directly to mail delivery, bypassing all Ruby Thread-related steps.

debug

private static void debug(RubyThread thread,
                          java.lang.String message)

kill_bang
```
public IRubyObject kill_bang()
```

safe_level
```
public IRubyObject safe_level()
```

backtrace

public IRubyObject backtrace(ThreadContext context)

backtrace20

public IRubyObject backtrace20(ThreadContext context,
                               IRubyObject[] args)

backtrace_locations

public IRubyObject backtrace_locations(ThreadContext context,
                                       IRubyObject[] args)

javaBacktrace

public java.lang.StackTraceElement[] javaBacktrace()

isCurrent
```
private boolean isCurrent()
```

exceptionRaised

public void exceptionRaised(RaiseException exception)

exceptionRaised
```
public void exceptionRaised(java.lang.Throwable exception)
```
For handling all non-Ruby exceptions bubbling out of threads

Parameters:

exception -

abortOnException

private boolean abortOnException(Ruby runtime)

mainThread

public static RubyThread mainThread(IRubyObject receiver)

selectForAccept

@Deprecated
public boolean selectForAccept(RubyIO io)

Deprecated.

getSelector

private java.nio.channels.Selector getSelector(java.nio.channels.SelectableChannel channel)
                                        throws java.io.IOException

Throws:: java.io.IOException

select

public boolean select(RubyIO io,
                      int ops)

select

public boolean select(RubyIO io,
                      int ops,
                      long timeout)

select

public boolean select(java.nio.channels.Channel channel,
                      RubyIO io,
                      int ops)

select

public boolean select(java.nio.channels.Channel channel,
                      RubyIO io,
                      int ops,
                      long timeout)

interrupt
```
public void interrupt()
```

waitForIO

public boolean waitForIO(ThreadContext context,
                         RubyIO io,
                         int ops)

beforeBlockingCall
```
public void beforeBlockingCall()
```

afterBlockingCall
```
public void afterBlockingCall()
```

receivedAnException

private void receivedAnException(ThreadContext context,
                                 IRubyObject exception)

wait_timeout

public boolean wait_timeout(IRubyObject o,
                            java.lang.Double timeout)
                     throws java.lang.InterruptedException

Throws:: java.lang.InterruptedException

getThreadGroup

public RubyThreadGroup getThreadGroup()

equals
```
public boolean equals(java.lang.Object obj)
```
Description copied from class: RubyObject

This method is just a wrapper around the Ruby "==" method, provided so that RubyObjects can be used as keys in the Java HashMap object underlying RubyHash.

Overrides:

equals in class RubyObject

hashCode
```
public int hashCode()
```
Description copied from class: RubyObject

Override the Object#hashCode method to make sure that the Ruby hash is actually used as the hashcode for Ruby objects. If the Ruby "hash" method doesn't return a number, the Object#hashCode implementation will be used instead.

Overrides:

hashCode in class RubyObject

toString
```
public java.lang.String toString()
```
Description copied from class: RubyObject

The default toString method is just a wrapper that calls the Ruby "to_s" method.

Overrides:

toString in class RubyObject

lock
```
public void lock(java.util.concurrent.locks.Lock lock)
```
Acquire the given lock, holding a reference to it for cleanup on thread termination.

Parameters:

lock - the lock to acquire, released on thread termination

lockInterruptibly
```
public void lockInterruptibly(java.util.concurrent.locks.Lock lock)
                       throws java.lang.InterruptedException
```
Acquire the given lock interruptibly, holding a reference to it for cleanup on thread termination.

Parameters:

lock - the lock to acquire, released on thread termination

Throws:

java.lang.InterruptedException - if the lock acquisition is interrupted

tryLock
```
public boolean tryLock(java.util.concurrent.locks.Lock lock)
```
Try to acquire the given lock, adding it to a list of held locks for cleanup on thread termination if it is acquired. Return immediately if the lock cannot be acquired.

Parameters:

lock - the lock to acquire, released on thread termination

unlock
```
public void unlock(java.util.concurrent.locks.Lock lock)
```
Release the given lock and remove it from the list of locks to be released on thread termination.

Parameters:

lock - the lock to release and dereferences

unlockAll
```
public void unlockAll()
```
Release all locks held.

identityString

private java.lang.String identityString()

Class RubyThread

Nested Class Summary

Nested classes/interfaces inherited from class org.jruby.RubyObject

Nested classes/interfaces inherited from class org.jruby.RubyBasicObject

Field Summary

Fields inherited from class org.jruby.RubyObject

Fields inherited from class org.jruby.RubyBasicObject

Fields inherited from interface org.jruby.runtime.builtin.IRubyObject

Constructor Summary

Method Summary

Methods inherited from class org.jruby.RubyObject

Methods inherited from class org.jruby.RubyBasicObject

Methods inherited from class java.lang.Object

Field Detail

LOG

threadImpl

threadLocalVariables

contextVariables

abortOnException

finalResult

exitingException

threadGroup

errorInfo

contextRef

DEBUG

RUBY_MIN_THREAD_PRIORITY

RUBY_MAX_THREAD_PRIORITY

status

mail

currentBlockingTask

heldLocks

disposed

initialPriority

currentSelector

blockingIO

Constructor Detail

RubyThread

RubyThread

Method Detail

receiveMail

checkMail

getErrorInfo

setErrorInfo

setContext

getContext

getNativeThread

beforeStart

dispose

createThreadClass

newInstance

start

start19

adopt

adoptThread

initialize

startWith

startThread

cleanTerminate

beDead

pollThreadEvents

pollThreadEvents

throwThreadKill

abort_on_exception_x

abort_on_exception_set_x

current

main

pass

list

addToCorrectThreadGroup

getSymbolKey

getThreadLocals

clearThreadLocals

getContextVariables

isAlive

op_aref

op_aset

abort_on_exception

abort_on_exception_set

alive_p

join