Dead
[official-gcc.git] / gomp-20050608-branch / libjava / classpath / java / lang / Thread.java
blob9afde5bfd0337867220fb1420271f9920e129ba7
1 /* Thread -- an independent thread of executable code
2 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004
3 Free Software Foundation
5 This file is part of GNU Classpath.
7 GNU Classpath is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
12 GNU Classpath is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Classpath; see the file COPYING. If not, write to the
19 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
20 02110-1301 USA.
22 Linking this library statically or dynamically with other modules is
23 making a combined work based on this library. Thus, the terms and
24 conditions of the GNU General Public License cover the whole
25 combination.
27 As a special exception, the copyright holders of this library give you
28 permission to link this library with independent modules to produce an
29 executable, regardless of the license terms of these independent
30 modules, and to copy and distribute the resulting executable under
31 terms of your choice, provided that you also meet, for each linked
32 independent module, the terms and conditions of the license of that
33 module. An independent module is a module which is not derived from
34 or based on this library. If you modify this library, you may extend
35 this exception to your version of the library, but you are not
36 obligated to do so. If you do not wish to do so, delete this
37 exception statement from your version. */
39 package java.lang;
41 import gnu.java.util.WeakIdentityHashMap;
42 import java.security.Permission;
43 import java.util.Map;
45 /* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
46 * "The Java Language Specification", ISBN 0-201-63451-1
47 * plus online API docs for JDK 1.2 beta from http://www.javasoft.com.
48 * Status: Believed complete to version 1.4, with caveats. We do not
49 * implement the deprecated (and dangerous) stop, suspend, and resume
50 * methods. Security implementation is not complete.
53 /**
54 * Thread represents a single thread of execution in the VM. When an
55 * application VM starts up, it creates a non-daemon Thread which calls the
56 * main() method of a particular class. There may be other Threads running,
57 * such as the garbage collection thread.
59 * <p>Threads have names to identify them. These names are not necessarily
60 * unique. Every Thread has a priority, as well, which tells the VM which
61 * Threads should get more running time. New threads inherit the priority
62 * and daemon status of the parent thread, by default.
64 * <p>There are two methods of creating a Thread: you may subclass Thread and
65 * implement the <code>run()</code> method, at which point you may start the
66 * Thread by calling its <code>start()</code> method, or you may implement
67 * <code>Runnable</code> in the class you want to use and then call new
68 * <code>Thread(your_obj).start()</code>.
70 * <p>The virtual machine runs until all non-daemon threads have died (either
71 * by returning from the run() method as invoked by start(), or by throwing
72 * an uncaught exception); or until <code>System.exit</code> is called with
73 * adequate permissions.
75 * <p>It is unclear at what point a Thread should be added to a ThreadGroup,
76 * and at what point it should be removed. Should it be inserted when it
77 * starts, or when it is created? Should it be removed when it is suspended
78 * or interrupted? The only thing that is clear is that the Thread should be
79 * removed when it is stopped.
81 * @author Tom Tromey
82 * @author John Keiser
83 * @author Eric Blake (ebb9@email.byu.edu)
84 * @see Runnable
85 * @see Runtime#exit(int)
86 * @see #run()
87 * @see #start()
88 * @see ThreadLocal
89 * @since 1.0
90 * @status updated to 1.4
92 public class Thread implements Runnable
94 /** The minimum priority for a Thread. */
95 public static final int MIN_PRIORITY = 1;
97 /** The priority a Thread gets by default. */
98 public static final int NORM_PRIORITY = 5;
100 /** The maximum priority for a Thread. */
101 public static final int MAX_PRIORITY = 10;
103 /** The underlying VM thread, only set when the thread is actually running.
105 volatile VMThread vmThread;
108 * The group this thread belongs to. This is set to null by
109 * ThreadGroup.removeThread when the thread dies.
111 volatile ThreadGroup group;
113 /** The object to run(), null if this is the target. */
114 final Runnable runnable;
116 /** The thread name, non-null. */
117 volatile String name;
119 /** Whether the thread is a daemon. */
120 volatile boolean daemon;
122 /** The thread priority, 1 to 10. */
123 volatile int priority;
125 /** Native thread stack size. 0 = use default */
126 private long stacksize;
128 /** Was the thread stopped before it was started? */
129 Throwable stillborn;
131 /** The context classloader for this Thread. */
132 private ClassLoader contextClassLoader;
134 /** The next thread number to use. */
135 private static int numAnonymousThreadsCreated;
137 /** Thread local storage. Package accessible for use by
138 * InheritableThreadLocal.
140 WeakIdentityHashMap locals;
143 * Allocates a new <code>Thread</code> object. This constructor has
144 * the same effect as <code>Thread(null, null,</code>
145 * <i>gname</i><code>)</code>, where <b><i>gname</i></b> is
146 * a newly generated name. Automatically generated names are of the
147 * form <code>"Thread-"+</code><i>n</i>, where <i>n</i> is an integer.
148 * <p>
149 * Threads created this way must have overridden their
150 * <code>run()</code> method to actually do anything. An example
151 * illustrating this method being used follows:
152 * <p><blockquote><pre>
153 * import java.lang.*;
155 * class plain01 implements Runnable {
156 * String name;
157 * plain01() {
158 * name = null;
160 * plain01(String s) {
161 * name = s;
163 * public void run() {
164 * if (name == null)
165 * System.out.println("A new thread created");
166 * else
167 * System.out.println("A new thread with name " + name +
168 * " created");
171 * class threadtest01 {
172 * public static void main(String args[] ) {
173 * int failed = 0 ;
175 * <b>Thread t1 = new Thread();</b>
176 * if (t1 != null)
177 * System.out.println("new Thread() succeed");
178 * else {
179 * System.out.println("new Thread() failed");
180 * failed++;
184 * </pre></blockquote>
186 * @see java.lang.Thread#Thread(java.lang.ThreadGroup,
187 * java.lang.Runnable, java.lang.String)
189 public Thread()
191 this(null, (Runnable) null);
195 * Allocates a new <code>Thread</code> object. This constructor has
196 * the same effect as <code>Thread(null, target,</code>
197 * <i>gname</i><code>)</code>, where <i>gname</i> is
198 * a newly generated name. Automatically generated names are of the
199 * form <code>"Thread-"+</code><i>n</i>, where <i>n</i> is an integer.
201 * @param target the object whose <code>run</code> method is called.
202 * @see java.lang.Thread#Thread(java.lang.ThreadGroup,
203 * java.lang.Runnable, java.lang.String)
205 public Thread(Runnable target)
207 this(null, target);
211 * Allocates a new <code>Thread</code> object. This constructor has
212 * the same effect as <code>Thread(null, null, name)</code>.
214 * @param name the name of the new thread.
215 * @see java.lang.Thread#Thread(java.lang.ThreadGroup,
216 * java.lang.Runnable, java.lang.String)
218 public Thread(String name)
220 this(null, null, name, 0);
224 * Allocates a new <code>Thread</code> object. This constructor has
225 * the same effect as <code>Thread(group, target,</code>
226 * <i>gname</i><code>)</code>, where <i>gname</i> is
227 * a newly generated name. Automatically generated names are of the
228 * form <code>"Thread-"+</code><i>n</i>, where <i>n</i> is an integer.
230 * @param group the group to put the Thread into
231 * @param target the Runnable object to execute
232 * @throws SecurityException if this thread cannot access <code>group</code>
233 * @throws IllegalThreadStateException if group is destroyed
234 * @see #Thread(ThreadGroup, Runnable, String)
236 public Thread(ThreadGroup group, Runnable target)
238 this(group, target, "Thread-" + ++numAnonymousThreadsCreated, 0);
242 * Allocates a new <code>Thread</code> object. This constructor has
243 * the same effect as <code>Thread(group, null, name)</code>
245 * @param group the group to put the Thread into
246 * @param name the name for the Thread
247 * @throws NullPointerException if name is null
248 * @throws SecurityException if this thread cannot access <code>group</code>
249 * @throws IllegalThreadStateException if group is destroyed
250 * @see #Thread(ThreadGroup, Runnable, String)
252 public Thread(ThreadGroup group, String name)
254 this(group, null, name, 0);
258 * Allocates a new <code>Thread</code> object. This constructor has
259 * the same effect as <code>Thread(null, target, name)</code>.
261 * @param target the Runnable object to execute
262 * @param name the name for the Thread
263 * @throws NullPointerException if name is null
264 * @see #Thread(ThreadGroup, Runnable, String)
266 public Thread(Runnable target, String name)
268 this(null, target, name, 0);
272 * Allocate a new Thread object, with the specified ThreadGroup and name, and
273 * using the specified Runnable object's <code>run()</code> method to
274 * execute. If the Runnable object is null, <code>this</code> (which is
275 * a Runnable) is used instead.
277 * <p>If the ThreadGroup is null, the security manager is checked. If a
278 * manager exists and returns a non-null object for
279 * <code>getThreadGroup</code>, that group is used; otherwise the group
280 * of the creating thread is used. Note that the security manager calls
281 * <code>checkAccess</code> if the ThreadGroup is not null.
283 * <p>The new Thread will inherit its creator's priority and daemon status.
284 * These can be changed with <code>setPriority</code> and
285 * <code>setDaemon</code>.
287 * @param group the group to put the Thread into
288 * @param target the Runnable object to execute
289 * @param name the name for the Thread
290 * @throws NullPointerException if name is null
291 * @throws SecurityException if this thread cannot access <code>group</code>
292 * @throws IllegalThreadStateException if group is destroyed
293 * @see Runnable#run()
294 * @see #run()
295 * @see #setDaemon(boolean)
296 * @see #setPriority(int)
297 * @see SecurityManager#checkAccess(ThreadGroup)
298 * @see ThreadGroup#checkAccess()
300 public Thread(ThreadGroup group, Runnable target, String name)
302 this(group, target, name, 0);
306 * Allocate a new Thread object, as if by
307 * <code>Thread(group, null, name)</code>, and give it the specified stack
308 * size, in bytes. The stack size is <b>highly platform independent</b>,
309 * and the virtual machine is free to round up or down, or ignore it
310 * completely. A higher value might let you go longer before a
311 * <code>StackOverflowError</code>, while a lower value might let you go
312 * longer before an <code>OutOfMemoryError</code>. Or, it may do absolutely
313 * nothing! So be careful, and expect to need to tune this value if your
314 * virtual machine even supports it.
316 * @param group the group to put the Thread into
317 * @param target the Runnable object to execute
318 * @param name the name for the Thread
319 * @param size the stack size, in bytes; 0 to be ignored
320 * @throws NullPointerException if name is null
321 * @throws SecurityException if this thread cannot access <code>group</code>
322 * @throws IllegalThreadStateException if group is destroyed
323 * @since 1.4
325 public Thread(ThreadGroup group, Runnable target, String name, long size)
327 // Bypass System.getSecurityManager, for bootstrap efficiency.
328 SecurityManager sm = SecurityManager.current;
329 Thread current = currentThread();
330 if (group == null)
332 if (sm != null)
333 group = sm.getThreadGroup();
334 if (group == null)
335 group = current.group;
337 else if (sm != null)
338 sm.checkAccess(group);
340 this.group = group;
341 // Use toString hack to detect null.
342 this.name = name.toString();
343 this.runnable = target;
344 this.stacksize = size;
346 priority = current.priority;
347 daemon = current.daemon;
348 contextClassLoader = current.contextClassLoader;
350 group.addThread(this);
351 InheritableThreadLocal.newChildThread(this);
355 * Used by the VM to create thread objects for threads started outside
356 * of Java. Note: caller is responsible for adding the thread to
357 * a group and InheritableThreadLocal.
359 * @param vmThread the native thread
360 * @param name the thread name or null to use the default naming scheme
361 * @param priority current priority
362 * @param daemon is the thread a background thread?
364 Thread(VMThread vmThread, String name, int priority, boolean daemon)
366 this.vmThread = vmThread;
367 this.runnable = null;
368 if (name == null)
369 name = "Thread-" + ++numAnonymousThreadsCreated;
370 this.name = name;
371 this.priority = priority;
372 this.daemon = daemon;
373 this.contextClassLoader = ClassLoader.getSystemClassLoader();
377 * Get the number of active threads in the current Thread's ThreadGroup.
378 * This implementation calls
379 * <code>currentThread().getThreadGroup().activeCount()</code>.
381 * @return the number of active threads in the current ThreadGroup
382 * @see ThreadGroup#activeCount()
384 public static int activeCount()
386 return currentThread().group.activeCount();
390 * Check whether the current Thread is allowed to modify this Thread. This
391 * passes the check on to <code>SecurityManager.checkAccess(this)</code>.
393 * @throws SecurityException if the current Thread cannot modify this Thread
394 * @see SecurityManager#checkAccess(Thread)
396 public final void checkAccess()
398 // Bypass System.getSecurityManager, for bootstrap efficiency.
399 SecurityManager sm = SecurityManager.current;
400 if (sm != null)
401 sm.checkAccess(this);
405 * Count the number of stack frames in this Thread. The Thread in question
406 * must be suspended when this occurs.
408 * @return the number of stack frames in this Thread
409 * @throws IllegalThreadStateException if this Thread is not suspended
410 * @deprecated pointless, since suspend is deprecated
412 public int countStackFrames()
414 VMThread t = vmThread;
415 if (t == null || group == null)
416 throw new IllegalThreadStateException();
418 return t.countStackFrames();
422 * Get the currently executing Thread. In the situation that the
423 * currently running thread was created by native code and doesn't
424 * have an associated Thread object yet, a new Thread object is
425 * constructed and associated with the native thread.
427 * @return the currently executing Thread
429 public static Thread currentThread()
431 return VMThread.currentThread();
435 * Originally intended to destroy this thread, this method was never
436 * implemented by Sun, and is hence a no-op.
438 public void destroy()
440 throw new NoSuchMethodError();
444 * Print a stack trace of the current thread to stderr using the same
445 * format as Throwable's printStackTrace() method.
447 * @see Throwable#printStackTrace()
449 public static void dumpStack()
451 new Throwable().printStackTrace();
455 * Copy every active thread in the current Thread's ThreadGroup into the
456 * array. Extra threads are silently ignored. This implementation calls
457 * <code>getThreadGroup().enumerate(array)</code>, which may have a
458 * security check, <code>checkAccess(group)</code>.
460 * @param array the array to place the Threads into
461 * @return the number of Threads placed into the array
462 * @throws NullPointerException if array is null
463 * @throws SecurityException if you cannot access the ThreadGroup
464 * @see ThreadGroup#enumerate(Thread[])
465 * @see #activeCount()
466 * @see SecurityManager#checkAccess(ThreadGroup)
468 public static int enumerate(Thread[] array)
470 return currentThread().group.enumerate(array);
474 * Get this Thread's name.
476 * @return this Thread's name
478 public final String getName()
480 VMThread t = vmThread;
481 return t == null ? name : t.getName();
485 * Get this Thread's priority.
487 * @return the Thread's priority
489 public final synchronized int getPriority()
491 VMThread t = vmThread;
492 return t == null ? priority : t.getPriority();
496 * Get the ThreadGroup this Thread belongs to. If the thread has died, this
497 * returns null.
499 * @return this Thread's ThreadGroup
501 public final ThreadGroup getThreadGroup()
503 return group;
507 * Checks whether the current thread holds the monitor on a given object.
508 * This allows you to do <code>assert Thread.holdsLock(obj)</code>.
510 * @param obj the object to test lock ownership on.
511 * @return true if the current thread is currently synchronized on obj
512 * @throws NullPointerException if obj is null
513 * @since 1.4
515 public static boolean holdsLock(Object obj)
517 return VMThread.holdsLock(obj);
521 * Interrupt this Thread. First, there is a security check,
522 * <code>checkAccess</code>. Then, depending on the current state of the
523 * thread, various actions take place:
525 * <p>If the thread is waiting because of {@link #wait()},
526 * {@link #sleep(long)}, or {@link #join()}, its <i>interrupt status</i>
527 * will be cleared, and an InterruptedException will be thrown. Notice that
528 * this case is only possible if an external thread called interrupt().
530 * <p>If the thread is blocked in an interruptible I/O operation, in
531 * {@link java.nio.channels.InterruptibleChannel}, the <i>interrupt
532 * status</i> will be set, and ClosedByInterruptException will be thrown.
534 * <p>If the thread is blocked on a {@link java.nio.channels.Selector}, the
535 * <i>interrupt status</i> will be set, and the selection will return, with
536 * a possible non-zero value, as though by the wakeup() method.
538 * <p>Otherwise, the interrupt status will be set.
540 * @throws SecurityException if you cannot modify this Thread
542 public synchronized void interrupt()
544 checkAccess();
545 VMThread t = vmThread;
546 if (t != null)
547 t.interrupt();
551 * Determine whether the current Thread has been interrupted, and clear
552 * the <i>interrupted status</i> in the process.
554 * @return whether the current Thread has been interrupted
555 * @see #isInterrupted()
557 public static boolean interrupted()
559 return VMThread.interrupted();
563 * Determine whether the given Thread has been interrupted, but leave
564 * the <i>interrupted status</i> alone in the process.
566 * @return whether the Thread has been interrupted
567 * @see #interrupted()
569 public boolean isInterrupted()
571 VMThread t = vmThread;
572 return t != null && t.isInterrupted();
576 * Determine whether this Thread is alive. A thread which is alive has
577 * started and not yet died.
579 * @return whether this Thread is alive
581 public final boolean isAlive()
583 return vmThread != null && group != null;
587 * Tell whether this is a daemon Thread or not.
589 * @return whether this is a daemon Thread or not
590 * @see #setDaemon(boolean)
592 public final boolean isDaemon()
594 VMThread t = vmThread;
595 return t == null ? daemon : t.isDaemon();
599 * Wait forever for the Thread in question to die.
601 * @throws InterruptedException if the Thread is interrupted; it's
602 * <i>interrupted status</i> will be cleared
604 public final void join() throws InterruptedException
606 join(0, 0);
610 * Wait the specified amount of time for the Thread in question to die.
612 * @param ms the number of milliseconds to wait, or 0 for forever
613 * @throws InterruptedException if the Thread is interrupted; it's
614 * <i>interrupted status</i> will be cleared
616 public final void join(long ms) throws InterruptedException
618 join(ms, 0);
622 * Wait the specified amount of time for the Thread in question to die.
624 * <p>Note that 1,000,000 nanoseconds == 1 millisecond, but most VMs do
625 * not offer that fine a grain of timing resolution. Besides, there is
626 * no guarantee that this thread can start up immediately when time expires,
627 * because some other thread may be active. So don't expect real-time
628 * performance.
630 * @param ms the number of milliseconds to wait, or 0 for forever
631 * @param ns the number of extra nanoseconds to sleep (0-999999)
632 * @throws InterruptedException if the Thread is interrupted; it's
633 * <i>interrupted status</i> will be cleared
634 * @throws IllegalArgumentException if ns is invalid
636 public final void join(long ms, int ns) throws InterruptedException
638 if(ms < 0 || ns < 0 || ns > 999999)
639 throw new IllegalArgumentException();
641 VMThread t = vmThread;
642 if(t != null)
643 t.join(ms, ns);
647 * Resume this Thread. If the thread is not suspended, this method does
648 * nothing. To mirror suspend(), there may be a security check:
649 * <code>checkAccess</code>.
651 * @throws SecurityException if you cannot resume the Thread
652 * @see #checkAccess()
653 * @see #suspend()
654 * @deprecated pointless, since suspend is deprecated
656 public final synchronized void resume()
658 checkAccess();
659 VMThread t = vmThread;
660 if (t != null)
661 t.resume();
665 * The method of Thread that will be run if there is no Runnable object
666 * associated with the Thread. Thread's implementation does nothing at all.
668 * @see #start()
669 * @see #Thread(ThreadGroup, Runnable, String)
671 public void run()
673 if (runnable != null)
674 runnable.run();
678 * Set the daemon status of this Thread. If this is a daemon Thread, then
679 * the VM may exit even if it is still running. This may only be called
680 * before the Thread starts running. There may be a security check,
681 * <code>checkAccess</code>.
683 * @param daemon whether this should be a daemon thread or not
684 * @throws SecurityException if you cannot modify this Thread
685 * @throws IllegalThreadStateException if the Thread is active
686 * @see #isDaemon()
687 * @see #checkAccess()
689 public final synchronized void setDaemon(boolean daemon)
691 if (vmThread != null)
692 throw new IllegalThreadStateException();
693 checkAccess();
694 this.daemon = daemon;
698 * Returns the context classloader of this Thread. The context
699 * classloader can be used by code that want to load classes depending
700 * on the current thread. Normally classes are loaded depending on
701 * the classloader of the current class. There may be a security check
702 * for <code>RuntimePermission("getClassLoader")</code> if the caller's
703 * class loader is not null or an ancestor of this thread's context class
704 * loader.
706 * @return the context class loader
707 * @throws SecurityException when permission is denied
708 * @see #setContextClassLoader(ClassLoader)
709 * @since 1.2
711 public synchronized ClassLoader getContextClassLoader()
713 // Bypass System.getSecurityManager, for bootstrap efficiency.
714 SecurityManager sm = SecurityManager.current;
715 if (sm != null)
716 // XXX Don't check this if the caller's class loader is an ancestor.
717 sm.checkPermission(new RuntimePermission("getClassLoader"));
718 return contextClassLoader;
722 * Sets the context classloader for this Thread. When not explicitly set,
723 * the context classloader for a thread is the same as the context
724 * classloader of the thread that created this thread. The first thread has
725 * as context classloader the system classloader. There may be a security
726 * check for <code>RuntimePermission("setContextClassLoader")</code>.
728 * @param classloader the new context class loader
729 * @throws SecurityException when permission is denied
730 * @see #getContextClassLoader()
731 * @since 1.2
733 public synchronized void setContextClassLoader(ClassLoader classloader)
735 SecurityManager sm = SecurityManager.current;
736 if (sm != null)
737 sm.checkPermission(new RuntimePermission("setContextClassLoader"));
738 this.contextClassLoader = classloader;
742 * Set this Thread's name. There may be a security check,
743 * <code>checkAccess</code>.
745 * @param name the new name for this Thread
746 * @throws NullPointerException if name is null
747 * @throws SecurityException if you cannot modify this Thread
749 public final synchronized void setName(String name)
751 checkAccess();
752 // The Class Libraries book says ``threadName cannot be null''. I
753 // take this to mean NullPointerException.
754 if (name == null)
755 throw new NullPointerException();
756 VMThread t = vmThread;
757 if (t != null)
758 t.setName(name);
759 else
760 this.name = name;
764 * Yield to another thread. The Thread will not lose any locks it holds
765 * during this time. There are no guarantees which thread will be
766 * next to run, and it could even be this one, but most VMs will choose
767 * the highest priority thread that has been waiting longest.
769 public static void yield()
771 VMThread.yield();
775 * Suspend the current Thread's execution for the specified amount of
776 * time. The Thread will not lose any locks it has during this time. There
777 * are no guarantees which thread will be next to run, but most VMs will
778 * choose the highest priority thread that has been waiting longest.
780 * @param ms the number of milliseconds to sleep.
781 * @throws InterruptedException if the Thread is (or was) interrupted;
782 * it's <i>interrupted status</i> will be cleared
783 * @throws IllegalArgumentException if ms is negative
784 * @see #interrupt()
786 public static void sleep(long ms) throws InterruptedException
788 sleep(ms, 0);
792 * Suspend the current Thread's execution for the specified amount of
793 * time. The Thread will not lose any locks it has during this time. There
794 * are no guarantees which thread will be next to run, but most VMs will
795 * choose the highest priority thread that has been waiting longest.
796 * <p>
797 * Note that 1,000,000 nanoseconds == 1 millisecond, but most VMs
798 * do not offer that fine a grain of timing resolution. When ms is
799 * zero and ns is non-zero the Thread will sleep for at least one
800 * milli second. There is no guarantee that this thread can start up
801 * immediately when time expires, because some other thread may be
802 * active. So don't expect real-time performance.
804 * @param ms the number of milliseconds to sleep
805 * @param ns the number of extra nanoseconds to sleep (0-999999)
806 * @throws InterruptedException if the Thread is (or was) interrupted;
807 * it's <i>interrupted status</i> will be cleared
808 * @throws IllegalArgumentException if ms or ns is negative
809 * or ns is larger than 999999.
810 * @see #interrupt()
812 public static void sleep(long ms, int ns) throws InterruptedException
815 // Check parameters
816 if (ms < 0 )
817 throw new IllegalArgumentException("Negative milliseconds: " + ms);
819 if (ns < 0 || ns > 999999)
820 throw new IllegalArgumentException("Nanoseconds ouf of range: " + ns);
822 // Really sleep
823 VMThread.sleep(ms, ns);
827 * Start this Thread, calling the run() method of the Runnable this Thread
828 * was created with, or else the run() method of the Thread itself. This
829 * is the only way to start a new thread; calling run by yourself will just
830 * stay in the same thread. The virtual machine will remove the thread from
831 * its thread group when the run() method completes.
833 * @throws IllegalThreadStateException if the thread has already started
834 * @see #run()
836 public synchronized void start()
838 if (vmThread != null || group == null)
839 throw new IllegalThreadStateException();
841 VMThread.create(this, stacksize);
845 * Cause this Thread to stop abnormally because of the throw of a ThreadDeath
846 * error. If you stop a Thread that has not yet started, it will stop
847 * immediately when it is actually started.
849 * <p>This is inherently unsafe, as it can interrupt synchronized blocks and
850 * leave data in bad states. Hence, there is a security check:
851 * <code>checkAccess(this)</code>, plus another one if the current thread
852 * is not this: <code>RuntimePermission("stopThread")</code>. If you must
853 * catch a ThreadDeath, be sure to rethrow it after you have cleaned up.
854 * ThreadDeath is the only exception which does not print a stack trace when
855 * the thread dies.
857 * @throws SecurityException if you cannot stop the Thread
858 * @see #interrupt()
859 * @see #checkAccess()
860 * @see #start()
861 * @see ThreadDeath
862 * @see ThreadGroup#uncaughtException(Thread, Throwable)
863 * @see SecurityManager#checkAccess(Thread)
864 * @see SecurityManager#checkPermission(Permission)
865 * @deprecated unsafe operation, try not to use
867 public final void stop()
869 stop(new ThreadDeath());
873 * Cause this Thread to stop abnormally and throw the specified exception.
874 * If you stop a Thread that has not yet started, the stop is ignored
875 * (contrary to what the JDK documentation says).
876 * <b>WARNING</b>This bypasses Java security, and can throw a checked
877 * exception which the call stack is unprepared to handle. Do not abuse
878 * this power.
880 * <p>This is inherently unsafe, as it can interrupt synchronized blocks and
881 * leave data in bad states. Hence, there is a security check:
882 * <code>checkAccess(this)</code>, plus another one if the current thread
883 * is not this: <code>RuntimePermission("stopThread")</code>. If you must
884 * catch a ThreadDeath, be sure to rethrow it after you have cleaned up.
885 * ThreadDeath is the only exception which does not print a stack trace when
886 * the thread dies.
888 * @param t the Throwable to throw when the Thread dies
889 * @throws SecurityException if you cannot stop the Thread
890 * @throws NullPointerException in the calling thread, if t is null
891 * @see #interrupt()
892 * @see #checkAccess()
893 * @see #start()
894 * @see ThreadDeath
895 * @see ThreadGroup#uncaughtException(Thread, Throwable)
896 * @see SecurityManager#checkAccess(Thread)
897 * @see SecurityManager#checkPermission(Permission)
898 * @deprecated unsafe operation, try not to use
900 public final synchronized void stop(Throwable t)
902 if (t == null)
903 throw new NullPointerException();
904 // Bypass System.getSecurityManager, for bootstrap efficiency.
905 SecurityManager sm = SecurityManager.current;
906 if (sm != null)
908 sm.checkAccess(this);
909 if (this != currentThread())
910 sm.checkPermission(new RuntimePermission("stopThread"));
912 VMThread vt = vmThread;
913 if (vt != null)
914 vt.stop(t);
915 else
916 stillborn = t;
920 * Suspend this Thread. It will not come back, ever, unless it is resumed.
922 * <p>This is inherently unsafe, as the suspended thread still holds locks,
923 * and can potentially deadlock your program. Hence, there is a security
924 * check: <code>checkAccess</code>.
926 * @throws SecurityException if you cannot suspend the Thread
927 * @see #checkAccess()
928 * @see #resume()
929 * @deprecated unsafe operation, try not to use
931 public final synchronized void suspend()
933 checkAccess();
934 VMThread t = vmThread;
935 if (t != null)
936 t.suspend();
940 * Set this Thread's priority. There may be a security check,
941 * <code>checkAccess</code>, then the priority is set to the smaller of
942 * priority and the ThreadGroup maximum priority.
944 * @param priority the new priority for this Thread
945 * @throws IllegalArgumentException if priority exceeds MIN_PRIORITY or
946 * MAX_PRIORITY
947 * @throws SecurityException if you cannot modify this Thread
948 * @see #getPriority()
949 * @see #checkAccess()
950 * @see ThreadGroup#getMaxPriority()
951 * @see #MIN_PRIORITY
952 * @see #MAX_PRIORITY
954 public final synchronized void setPriority(int priority)
956 checkAccess();
957 if (priority < MIN_PRIORITY || priority > MAX_PRIORITY)
958 throw new IllegalArgumentException("Invalid thread priority value "
959 + priority + ".");
960 priority = Math.min(priority, group.getMaxPriority());
961 VMThread t = vmThread;
962 if (t != null)
963 t.setPriority(priority);
964 else
965 this.priority = priority;
969 * Returns a string representation of this thread, including the
970 * thread's name, priority, and thread group.
972 * @return a human-readable String representing this Thread
974 public String toString()
976 return ("Thread[" + name + "," + priority + ","
977 + (group == null ? "" : group.getName()) + "]");
981 * Clean up code, called by VMThread when thread dies.
983 synchronized void die()
985 group.removeThread(this);
986 vmThread = null;
987 locals = null;
991 * Returns the map used by ThreadLocal to store the thread local values.
993 static Map getThreadLocals()
995 Thread thread = currentThread();
996 Map locals = thread.locals;
997 if (locals == null)
999 locals = thread.locals = new WeakIdentityHashMap();
1001 return locals;