Uses of Class
java.lang.Thread

Packages that use Thread

com.aicas.jamaica.lang	Provides classes that are specific to JamaicaVM including access to the CPU timer, debugging support, and an API for generating and dumping profiles.
java.lang	Provides classes that are fundamental to the design of the Java programming language.
java.util.concurrent	Utility classes commonly useful in concurrent programming.
java.util.concurrent.locks	Interfaces and classes providing a framework for locking and waiting for conditions that is distinct from built-in synchronization and monitors.
javax.realtime	Jamaica's implementation of the Real-Time Specification for Java.
javax.swing.text	Provides classes and interfaces that deal with editable and noneditable text components.

Uses of Thread in com.aicas.jamaica.lang

Methods in com.aicas.jamaica.lang that return Thread

static Thread	Debug.getOwner(Object monitor) Determines the owner of a given Java monitor.
Thread	MemoryBudget.thread() The thread this budget is assigned to

Methods in com.aicas.jamaica.lang with parameters of type Thread

static void	Debug.dumpStackOf(Thread thread) Prints the stack trace of the given thread using a native function, i.e., without requiring the VM and java.lang, java.io classes to be initialized and without memory allocation.
static long	CpuTime.getAccurateCpuTime(Thread t) get high resolution Java execution time of a given thread.
static RelativeTime	CpuTime.getAccurateCpuTime(Thread t, RelativeTime time) This method retrieves the current CPU time that was consumed by the given thread and stores it into the given relativeTime-object.
static long	CpuTime.getCpuTime(Thread t) get high resolution Java execution time of a given thread.
static long	Debug.getExecutionTime(Thread thread) Gets high resolution Java execution time of given thread (may include the execution time of any non-java thread that preempted this thread, does not include execution time of native JNI code).
static long	Debug.getGarbageCollectionTime(Thread thread) Gets high resolution execution time spent for garbage collection work by given thread (may include the execution time of any non-java thread that preempted this thread's garbage collection activity).
static long	Debug.getInterpreterTime(Thread thread) Gets high resolution execution time spent by interpreted Java code by given thread (may include the execution time of any non-java thread that preempted this thread's interpreter activity).
static int	Debug.getThreadId(Thread thread) Returns the JamaicaVM thread id for a given thread.
static long	CpuTime.getTotalCpuTime(Thread t) get high resolution total execution time of given thread.
static long	Debug.getTotalExecutionTime(Thread thread) Gets high resolution total execution time of given thread (may include the execution time of any non-java thread that preempted this thread or any thread that preempted this thread's native code).
static void	Wait.join(Thread thread) Wait for termination of a given thread.
static int	Scheduler.microAdjustPriority(Thread t, int microAdjustment) microAdjustPriority enables to slightly change the priority of a running thread such that it will have precedence over other threads with the same Java priority (+1) or other threads will have priority over this thread (-1), or it will be treated equally (0).
static void	AllocationHandler.removeAllocationHandler(Thread t, AllocationHandler h) Remove the given memory handler.
static void	AllocationHandler.setAllocationHandler(Thread t, AllocationHandler h) set the allocation handler for a given thread
static void	Scheduler.setLeastEligible(Thread t, boolean b) This method sets the attribute that indicates that this thread has least eligibility to run.

Constructors in com.aicas.jamaica.lang with parameters of type Thread

MemoryBudget(Thread t, long budget)
Add a budget for a given thread

Uses of Thread in java.lang

Methods in java.lang that return Thread

static Thread

Thread.currentThread() currentThread returns a reference to the current thread.

Methods in java.lang that return types with arguments of type Thread

static Map<Thread,StackTraceElement[]>

Thread.getAllStackTraces() Gets the stack traces of all currently alive threads.

Methods in java.lang with parameters of type Thread

void	Runtime.addShutdownHook(Thread hook) add a shutdown hook adds a shutdown hook that will be started on a call to exit(int).
void	SecurityManager.checkAccess(Thread t) Throws a SecurityException if the calling thread is not allowed to modify the thread argument.
int	ThreadGroup.enumerate(Thread[] array) enumerate enumerates all the threads in this thread group and any sub groups and stores the threads in the given array.
static int	Thread.enumerate(Thread[] tarray) enumerate enumberates all active threads in the current thread's thread group.
int	ThreadGroup.enumerate(Thread[] array, boolean recursive) enumerate copies into the specified array every active thread in this thread group.
boolean	Runtime.removeShutdownHook(Thread hook) remove a shutdown hook that was registered using addShutdownHook.
void	ThreadGroup.uncaughtException(Thread t, Throwable e) uncaughtException is called by the virtual machine if one thread of this thread group is terminated by an unhandled exception and this thread did not set its own uncaught exception handler.
void	Thread.UncaughtExceptionHandler.uncaughtException(Thread thread, Throwable exception) Handle an uncaught exception.

Uses of Thread in java.util.concurrent

Methods in java.util.concurrent that return Thread

Thread

ThreadFactory.newThread(Runnable r) Constructs a new Thread.

Methods in java.util.concurrent that return types with arguments of type Thread

protected Collection<Thread>

Semaphore.getQueuedThreads() Returns a collection containing threads that may be waiting to acquire.

Methods in java.util.concurrent with parameters of type Thread

protected void	ThreadPoolExecutor.beforeExecute(Thread t, Runnable r) Method invoked prior to executing the given Runnable in the given thread.
void	TimeUnit.timedJoin(Thread thread, long timeout) Performs a timed Thread.join using this time unit.

Uses of Thread in java.util.concurrent.locks

Methods in java.util.concurrent.locks that return Thread

protected Thread	AbstractOwnableSynchronizer.getExclusiveOwnerThread() Returns the thread last set by setExclusiveOwnerThread, or null if never set.
Thread	AbstractQueuedLongSynchronizer.getFirstQueuedThread() Returns the first (longest-waiting) thread in the queue, or null if no threads are currently queued.
Thread	AbstractQueuedSynchronizer.getFirstQueuedThread() Returns the first (longest-waiting) thread in the queue, or null if no threads are currently queued.
protected Thread	ReentrantReadWriteLock.getOwner() Returns the thread that currently owns the write lock, or null if not owned.
protected Thread	ReentrantLock.getOwner() Returns the thread that currently owns this lock, or null if not owned.

Methods in java.util.concurrent.locks that return types with arguments of type Thread

Collection<Thread>	AbstractQueuedLongSynchronizer.getExclusiveQueuedThreads() Returns a collection containing threads that may be waiting to acquire in exclusive mode.
Collection<Thread>	AbstractQueuedSynchronizer.getExclusiveQueuedThreads() Returns a collection containing threads that may be waiting to acquire in exclusive mode.
protected Collection<Thread>	ReentrantReadWriteLock.getQueuedReaderThreads() Returns a collection containing threads that may be waiting to acquire the read lock.
protected Collection<Thread>	ReentrantReadWriteLock.getQueuedThreads() Returns a collection containing threads that may be waiting to acquire either the read or write lock.
protected Collection<Thread>	ReentrantLock.getQueuedThreads() Returns a collection containing threads that may be waiting to acquire this lock.
Collection<Thread>	AbstractQueuedLongSynchronizer.getQueuedThreads() Returns a collection containing threads that may be waiting to acquire.
Collection<Thread>	AbstractQueuedSynchronizer.getQueuedThreads() Returns a collection containing threads that may be waiting to acquire.
protected Collection<Thread>	ReentrantReadWriteLock.getQueuedWriterThreads() Returns a collection containing threads that may be waiting to acquire the write lock.
Collection<Thread>	AbstractQueuedLongSynchronizer.getSharedQueuedThreads() Returns a collection containing threads that may be waiting to acquire in shared mode.
Collection<Thread>	AbstractQueuedSynchronizer.getSharedQueuedThreads() Returns a collection containing threads that may be waiting to acquire in shared mode.
protected Collection<Thread>	AbstractQueuedLongSynchronizer.ConditionObject.getWaitingThreads() Returns a collection containing those threads that may be waiting on this Condition.
protected Collection<Thread>	AbstractQueuedSynchronizer.ConditionObject.getWaitingThreads() Returns a collection containing those threads that may be waiting on this Condition.
Collection<Thread>	AbstractQueuedLongSynchronizer.getWaitingThreads(AbstractQueuedLongSynchronizer.ConditionObject condition) Returns a collection containing those threads that may be waiting on the given condition associated with this synchronizer.
Collection<Thread>	AbstractQueuedSynchronizer.getWaitingThreads(AbstractQueuedSynchronizer.ConditionObject condition) Returns a collection containing those threads that may be waiting on the given condition associated with this synchronizer.
protected Collection<Thread>	ReentrantReadWriteLock.getWaitingThreads(Condition condition) Returns a collection containing those threads that may be waiting on the given condition associated with the write lock.
protected Collection<Thread>	ReentrantLock.getWaitingThreads(Condition condition) Returns a collection containing those threads that may be waiting on the given condition associated with this lock.

Methods in java.util.concurrent.locks with parameters of type Thread

static Object	LockSupport.getBlocker(Thread t) Returns the blocker object supplied to the most recent invocation of a park method that has not yet unblocked, or null if not blocked.
boolean	ReentrantReadWriteLock.hasQueuedThread(Thread thread) Queries whether the given thread is waiting to acquire either the read or write lock.
boolean	ReentrantLock.hasQueuedThread(Thread thread) Queries whether the given thread is waiting to acquire this lock.
boolean	AbstractQueuedLongSynchronizer.isQueued(Thread thread) Returns true if the given thread is currently queued.
boolean	AbstractQueuedSynchronizer.isQueued(Thread thread) Returns true if the given thread is currently queued.
protected void	AbstractOwnableSynchronizer.setExclusiveOwnerThread(Thread t) Sets the thread that currently owns exclusive access.
static void	LockSupport.unpark(Thread thread) Makes available the permit for the given thread, if it was not already available.

Uses of Thread in javax.realtime

Subclasses of Thread in javax.realtime

class	NoHeapRealtimeThread Jamaica Real-Time Specification for Java class NoHeapRealTimeThread.
class	RealtimeThread Jamaica Real-Time Specification for Java class RealtimeThread.

Methods in javax.realtime with parameters of type Thread

static Affinity	Affinity.get(Thread thread) Return the affinity set that was set for a given thread.
static int	PriorityScheduler.getMaxPriority(Thread thread) getMaxPriority returns the maximum priority allowed for a thread.
static int	PriorityScheduler.getMinPriority(Thread thread) getMinPriority returns the minimum priority allowed for a thread.
static int	PriorityScheduler.getNormPriority(Thread thread) getNormPriority returns the normal priority for a thread.
static void	Affinity.set(Affinity set, Thread thread) Set the CPU affinity of a given thread.
void	ProcessingGroupParameters.Visitor.visit(Thread t)

Uses of Thread in javax.swing.text

Methods in javax.swing.text that return Thread

protected Thread

AbstractDocument.getCurrentWriter() Fetches the current writing thread if there is one.