java线程简述

 1 public enum State {
 2         /**
 3          * 线程未启动状态
 4          */
 5         NEW,
 6 
 7         /**
 8          * 在执行状态，但不排除等待其他操作系统资源的情况
 9          */
10         RUNNABLE,
11 
12         /**
13          * 等待监视器锁的状态
14          */
15         BLOCKED,
16 
17         /**
18          * 等待状态， 会由object.wait(), join(), LockSupport.park()引起
19          */
20         WAITING,
21 
22         /**
23          * 有超时限制的等待状态，相比于WAITING，多了一个等待的时间
24          */
25         TIMED_WAITING,
26 
27         /**
28          * 结束状态
29          */
30         TERMINATED;
31 }

 1 public synchronized void start() {
 2         if (threadStatus != 0)
 3             throw new IllegalThreadStateException();
 4 
 5         /* Notify the group that this thread is about to be started
 6          * so that it can be added to the group's list of threads
 7          * and the group's unstarted count can be decremented. */
 8         group.add(this);
 9 
10         boolean started = false;
11         try {
12             start0();
13             started = true;
14         } finally {
15             try {
16                 if (!started) {
17                     group.threadStartFailed(this);
18                 }
19             } catch (Throwable ignore) {
20                 /* do nothing. If start0 threw a Throwable then
21                   it will be passed up the call stack */
22             }
23         }
24 }

 1 public final synchronized void stop(Throwable obj) {
 2 	if (obj == null)
 3 		throw new NullPointerException();
 4 
 5 	SecurityManager security = System.getSecurityManager();
 6 	if (security != null) {
 7 		checkAccess();
 8     	if ((this != Thread.currentThread()) ||
 9 			(!(obj instanceof ThreadDeath))) {
10                 security.checkPermission(SecurityConstants.STOP_THREAD_PERMISSION);
11             }
12         }
13    	// A zero status value corresponds to "NEW", it can't change to
14     // not-NEW because we hold the lock.
15     if (threadStatus != 0) {
16         resume(); // Wake up thread if it was suspended; no-op otherwise
17     }
18 
19     // The VM can handle all thread states
20     stop0(obj);
21 }

 1 public void interrupt() {
 2 	if (this != Thread.currentThread())
 3 		checkAccess();
 4 
 5     synchronized (blockerLock) {
 6         Interruptible b = blocker;
 7         if (b != null) {
 8             interrupt0();           // Just to set the interrupt flag
 9             b.interrupt(this);
10             return;
11         }
12     }
13     interrupt0();
14 }

1 public static boolean interrupted() {
2    return currentThread().isInterrupted(true);
3 }
4 
5 public boolean isInterrupted() {
6     return isInterrupted(false);
7 }

1 /**
2  * Tests if some Thread has been interrupted.  The interrupted state
3  * is reset or not based on the value of ClearInterrupted that is
4  * passed.
5  */
6 private native boolean isInterrupted(boolean ClearInterrupted);

 1 /**
 2      * A hint to the scheduler that the current thread is willing to yield
 3      * its current use of a processor. The scheduler is free to ignore this
 4      * hint.
 5      *
 6      * <p> Yield is a heuristic attempt to improve relative progression
 7      * between threads that would otherwise over-utilise a CPU. Its use
 8      * should be combined with detailed profiling and benchmarking to
 9      * ensure that it actually has the desired effect.
10      *
11      * <p> It is rarely appropriate to use this method. It may be useful
12      * for debugging or testing purposes, where it may help to reproduce
13      * bugs due to race conditions. It may also be useful when designing
14      * concurrency control constructs such as the ones in the
15      * {@link java.util.concurrent.locks} package.
16      */
17     public static native void yield();

 1 /**
 2      * Waits for this thread to die.
 3      *
 4      * <p> An invocation of this method behaves in exactly the same
 5      * way as the invocation
 6      *
 7      * <blockquote>
 8      * {@linkplain #join(long) join}{@code (0)}
 9      * </blockquote>
10      *
11      * @throws  InterruptedException
12      *          if any thread has interrupted the current thread. The
13      *          <i>interrupted status</i> of the current thread is
14      *          cleared when this exception is thrown.
15      */
16     public final void join() throws InterruptedException {
17         join(0);
18     }