/* VMThread -- VM interface for Thread of executable code Copyright (C) 2003 Free Software Foundation This file is part of GNU Classpath. GNU Classpath is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GNU Classpath is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU Classpath; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. Linking this library statically or dynamically with other modules is making a combined work based on this library. Thus, the terms and conditions of the GNU General Public License cover the whole combination. As a special exception, the copyright holders of this library give you permission to link this library with independent modules to produce an executable, regardless of the license terms of these independent modules, and to copy and distribute the resulting executable under terms of your choice, provided that you also meet, for each linked independent module, the terms and conditions of the license of that module. An independent module is a module which is not derived from or based on this library. If you modify this library, you may extend this exception to your version of the library, but you are not obligated to do so. If you do not wish to do so, delete this exception statement from your version. */ package java.lang; /** * VM interface for Thread of executable code. Holds VM dependent state. * It is deliberately package local and final and should only be accessed * by the Thread class. *

* This is the GNU Classpath reference implementation, it should be adapted * for a specific VM. *

* The following methods must be implemented: *

* All other methods may be implemented to make Thread handling more efficient * or to implement some optional (and sometimes deprecated) behaviour. Default * implementations are provided but it is highly recommended to optimize them * for a specific VM. * * @author Jeroen Frijters (jeroen@frijters.net) */ final class VMThread { /** * The Thread object that this VM state belongs to. * Used in currentThread() and start(). * Note: when this thread dies, this reference is *not* cleared */ volatile Thread thread; /** * Flag that is set when the thread runs, used by stop() to protect against * stop's getting lost. */ private volatile boolean running; /** * Private constructor, create VMThreads with the static create method. * * @param thread The Thread object that was just created. */ private VMThread(Thread thread) { this.thread = thread; } /** * This method is the initial Java code that gets executed when a native * thread starts. It's job is to coordinate with the rest of the VMThread * logic and to start executing user code and afterwards handle clean up. */ private void run() { try { try { running = true; synchronized(thread) { Throwable t = thread.stillborn; if(t != null) { thread.stillborn = null; throw t; } } thread.run(); } catch(Throwable t) { try { thread.group.uncaughtException(thread, t); } catch(Throwable ignore) { } } } finally { // Setting runnable to false is partial protection against stop // being called while we're cleaning up. To be safe all code in // VMThread be unstoppable. running = false; thread.die(); synchronized(this) { // release the threads waiting to join us notifyAll(); } } } /** * Creates a native Thread. This is called from the start method of Thread. * The Thread is started. * * @param thread The newly created Thread object * @param stacksize Indicates the requested stacksize. Normally zero, * non-zero values indicate requested stack size in bytes but it is up * to the specific VM implementation to interpret them and may be ignored. */ static void create(Thread thread, long stacksize) { VMThread vmThread = new VMThread(thread); vmThread.start(stacksize); thread.vmThread = vmThread; } /** * Gets the name of the thread. Usually this is the name field of the * associated Thread object, but some implementation might choose to * return the name of the underlying platform thread. */ String getName() { return thread.name; } /** * Set the name of the thread. Usually this sets the name field of the * associated Thread object, but some implementations might choose to * set the name of the underlying platform thread. * @param name The new name */ void setName(String name) { thread.name = name; } /** * Set the thread priority field in the associated Thread object and * calls the native method to set the priority of the underlying * platform thread. * @param priority The new priority */ void setPriority(int priority) { thread.priority = priority; nativeSetPriority(priority); } /** * Returns the priority. Usually this is the priority field from the * associated Thread object, but some implementation might choose to * return the priority of the underlying platform thread. * @return this Thread's priority */ int getPriority() { return thread.priority; } /** * Returns true if the thread is a daemon thread. Usually this is the * daemon field from the associated Thread object, but some * implementation might choose to return the daemon state of the underlying * platform thread. * @return whether this is a daemon Thread or not */ boolean isDaemon() { return thread.daemon; } /** * Returns the number of stack frames in this Thread. * Will only be called when when a previous call to suspend() returned true. * * @deprecated unsafe operation */ int countStackFrames() { return 0; } /** * Wait the specified amount of time for the Thread in question to die. * *

Note that 1,000,000 nanoseconds == 1 millisecond, but most VMs do * not offer that fine a grain of timing resolution. Besides, there is * no guarantee that this thread can start up immediately when time expires, * because some other thread may be active. So don't expect real-time * performance. * * @param ms the number of milliseconds to wait, or 0 for forever * @param ns the number of extra nanoseconds to sleep (0-999999) * @throws InterruptedException if the Thread is interrupted; it's * interrupted status will be cleared */ synchronized void join(long ms, int ns) throws InterruptedException { // round up ms += (ns != 0) ? 1 : 0; long end = System.currentTimeMillis() + ms; // Apparently, some VMs will return from wait without notify having // been called, so we loop and test the vmThread field in our // corresponding Thread object. while(thread.vmThread != null) { // We use the VMThread object to wait on, because this is a private // object, so client code cannot call notify on us. wait(ms); if(ms != 0) { long now = System.currentTimeMillis(); ms = end - now; if(ms <= 0) { break; } } } } /** * Cause this Thread to stop abnormally and throw the specified exception. * If you stop a Thread that has not yet started, the stop is ignored * (contrary to what the JDK documentation says). * WARNINGThis bypasses Java security, and can throw a checked * exception which the call stack is unprepared to handle. Do not abuse * this power. * *

This is inherently unsafe, as it can interrupt synchronized blocks and * leave data in bad states. * *

NOTE stop() should take care not to stop a thread if it is * executing code in this class. * * @param t the Throwable to throw when the Thread dies * @deprecated unsafe operation, try not to use */ void stop(Throwable t) { // Note: we assume that we own the lock on thread // (i.e. that Thread.stop() is synchronized) if(running) nativeStop(t); else thread.stillborn = t; } /** * Create a native thread on the underlying platform and start it executing * on the run method of this object. * @param stacksize the requested size of the native thread stack */ native void start(long stacksize); /** * Interrupt this thread. */ native void interrupt(); /** * Determine whether this Thread has been interrupted, but leave * the interrupted status alone in the process. * * @return whether the Thread has been interrupted */ native boolean isInterrupted(); /** * Suspend this Thread. It will not come back, ever, unless it is resumed. */ native void suspend(); /** * Resume this Thread. If the thread is not suspended, this method does * nothing. */ native void resume(); /** * Set the priority of the underlying platform thread. * * @param priority the new priority */ native void nativeSetPriority(int priority); /** * Asynchronously throw the specified throwable in this Thread. * * @param t the exception to throw */ native void nativeStop(Throwable t); /** * Return the Thread object associated with the currently executing * thread. * * @return the currently executing Thread */ native static Thread currentThread(); /** * Yield to another thread. The Thread will not lose any locks it holds * during this time. There are no guarantees which thread will be * next to run, and it could even be this one, but most VMs will choose * the highest priority thread that has been waiting longest. */ static native void yield(); /** * Suspend the current Thread's execution for the specified amount of * time. The Thread will not lose any locks it has during this time. There * are no guarantees which thread will be next to run, but most VMs will * choose the highest priority thread that has been waiting longest. * *

Note that 1,000,000 nanoseconds == 1 millisecond, but most VMs do * not offer that fine a grain of timing resolution. Besides, there is * no guarantee that this thread can start up immediately when time expires, * because some other thread may be active. So don't expect real-time * performance. * * @param ms the number of milliseconds to sleep, or 0 for forever * @param ns the number of extra nanoseconds to sleep (0-999999) * @throws InterruptedException if the Thread is interrupted; it's * interrupted status will be cleared * @throws IllegalArgumentException if ns is invalid */ static native void sleep(long ms, int ns) throws InterruptedException; /** * Determine whether the current Thread has been interrupted, and clear * the interrupted status in the process. * * @return whether the current Thread has been interrupted */ static native boolean interrupted(); /** * Checks whether the current thread holds the monitor on a given object. * This allows you to do assert Thread.holdsLock(obj). * * @param obj the object to check * @return true if the current thread is currently synchronized on obj * @throws NullPointerException if obj is null */ static native boolean holdsLock(Object obj); }