爱站程序员基地静态方法：
Thread类中的静态方法表示操作的线程是\”正在执行静态方法所在的代码块的线程\”。
为什么Thread类中要有静态方法，这样就能对CPU当前正在运行的线程进行操作。下面来看一下Thread类中的静态方法：
1：currentThread
/*** Returns a reference to the currently executing thread object.** @return the currently executing thread.*/public static native Thread currentThread();
currentThread()方法返回的是对当前正在执行线程对象的引用。
/*** 测试Thread.currentThread()：返回代码段正在被哪个线程调用的信息* this 始终表示线程实例本身** @author yuxiaoyu*/public class Mythread4 extends Thread { static { System.out.println(\"Mythread4静态块的打印：Thread.currentThread().getName()=\" + Thread.currentThread().getName()); }public Mythread4() {System.out.println(\"Mythread4构造方法：Thread.currentThread().getName()=\" + Thread.currentThread().getName());System.out.println(\"Mythread4构造方法：this.getName()=\" + this.getName());}public void run() {System.out.println(\"run 方法：Thread.currentThread().getName()=\" + Thread.currentThread().getName());System.out.println(\"run 方法：this.getName()=\" + this.getName());}}
@Testpublic void test4() {Mythread4 a = new Mythread4();a.start();}
执行结果：
Mythread4静态块的打印：Thread.currentThread().getName()=mainMythread4构造方法：Thread.currentThread().getName()=mainMythread4构造方法：this.getName()=Thread-0run 方法：Thread.currentThread().getName()=Thread-0run 方法：this.getName()=Thread-0
这个结果说明，线程类的构造方法、静态块是被main线程调用的，而线程类的run()方法才是应用线程自己调用的，this 始终表示线程实例本身。
2：sleep
/*** Causes the currently executing thread to sleep (temporarily cease* execution) for the specified number of milliseconds, subject to* the precision and accuracy of system timers and schedulers. The thread* does not lose ownership of any monitors.** @param millis* the length of time to sleep in milliseconds** @throws IllegalArgumentException* if the value of {@code millis} is negative** @throws InterruptedException* if any thread has interrupted the current thread. The* <i>interrupted status</i> of the current thread is* cleared when this exception is thrown.*/public static native void sleep(long millis) throws InterruptedException;
该方法是让正在执行的线路休眠指定毫秒，注意API的注释中“The thread does not lose ownership of any monitors.”表示线程不会失去任何监视器的所有权。
简单说就是sleep代码上下文如果被加锁了，那么在休眠的时间内，锁依然在，但是CPU资源会让出给其他线程。
3：yield
/*** A hint to the scheduler that the current thread is willing to yield* its current use of a processor. The scheduler is free to ignore this* hint.** <p> Yield is a heuristic attempt to improve relative progression* between threads that would otherwise over-utilise a CPU. Its use* should be combined with detailed profiling and benchmarking to* ensure that it actually has the desired effect.** <p> It is rarely appropriate to use this method. It may be useful* for debugging or testing purposes, where it may help to reproduce* bugs due to race conditions. It may also be useful when designing* concurrency control constructs such as the ones in the* {@link java.util.concurrent.locks} package.*/public static native void yield();
该方法表示给调度程序的一个提示:当前线程愿意让出它当前对处理器的使用。调度程序可以自由地忽略这个提示。
public class Mythread5 extends Thread {public void run() {long beginTime = System.currentTimeMillis();int count = 0;for (int i = 0; i < 50000000; i++){Thread.yield();count = count + i + 1;}long endTad8ime = System.currentTimeMillis();System.out.println(\"用时：\" + (endTime - beginTime) + \"毫秒！\");}}
第一次运行结果：用时：34872毫秒！
第二次运行结果：用时：33738毫秒！
如果将Thread.yield(); 注释掉的话，运行结果：用时：48毫秒！。
看到，每次执行的用时都不一样，证明了yield()方法放弃CPU的时间并不确定，而且yield方法将CPU资源让给其他资源导致变慢。
4：interrupted()
/*** Tests whether the current thread has been interrupted. The* <i>interrupted status</i> of the thread is cleared by this method. In* other words, if this method were to be called twice in succession, the* second call would return false (unless the current thread were* interrupted again, after the first call had cleared its interrupted* status and before the second call had examined it).** <p>A thread interruption ignored because a thread was not alive* at the time of the interrupt will be reflected by this method* returning false.** @return <code>true</code> if the current thread has been interrupted;* <code>false</code> otherwise.* @see #isInterrupted()* @revised 6.0*/public static boolean interrupted() {return currentThread().isInterrupted(true);}
/*** Tests if some Thread has been interrupted. The interrupted state* is reset or not based on the value of ClearInterrupted that is* passed.*/private native boolean isInterrupted(boolean ClearInterrupted);
测试当前线程是否已经中断，并清除线程的中断状态。
实例方法
1：start
/*** Causes this thread to begin execution; the Java Virtual Machine* calls the <code>run</code> method of this thread.* <p>* The result is that two threads are running concurrently: the* current thread (which returns from the call to the* <code>start</code> method) and the other thread (which executes its* <code>run</code> method).* <p>* It is never legal to start a thread more than once.* In particular, a thread may not be restarted once it has completed* execution.** @exception IllegalThrea15a8dStateException if the thread was already* started.* @see #run()* @see #stop()*/public synchronized void start() {/*** This method is not invoked for the main method thread or \"system\"* group threads created/set up by the VM. Any new functionality added* to this method in the future may have to also be added to the VM.** A zero status value corresponds to state \"NEW\".*/if (threadStatus != 0)throw new IllegalThreadStateException();/* Notify the group that this thread is about to be started* so that it can be added to the group\'s list of threads* and the group\'s unstarted count can be decremented. */group.add(this);boolean started = false;try {start0();started = true;} finally {try {if (!started) {group.threadStartFailed(this);}} catch (Throwable ignore) {/* do nothing. If start0 threw a Throwable thenit will be passed up the call stack */}}}
此方法告诉线程执行器，这个线程可以执行了。
2：isAlive
/*** Tests if this thread is alive. A thread is alive if it has* been started and has not yet died.** @return <code>true</code> if this thread is alive;* <code>false</code> otherwise.*/public final native boolean isAlive();
判断当前的线程是否处于活动状态，活动状态就是线程已经启动且尚未终止。线程处于正在运行或准备开始运行的状态，就认为线程是“存活”的。
public class Mythread7_2 extends Thread {public Mythread7_2() {System.out.println(\"Mythread7_2---begin\");System.out.println(\"Thread.currentThread().getName()=\" + Thread.currentThread().getName());System.out.println(\"Thread.currentThread().isAlive()=\" + Thread.currentThread().isAlive());System.out.println(\"this.getName()=\" + this.getName());System.out.println(\"this.isAlive()=\" + this.isAlive());System.out.println(\"Mythread7_2---end\");}@Overridepublic void run() {System.out.println(\"run---begin\");System.out.println(\"Thread.currentThread().getName()=\" + Thread.currentThread().getName());System.out.println(\"Thread.currentThread().isAlive()=\" + Thread.currentThread().isAlive());System.out.println(\"this.getName()=\" + this.getName());System.out.println(\"this.isAlive()=\" + this.isAlive());System.out.println(\"run---end\");}}
@Testpublic void test7_2() {Mythread7_2 c = new Mythread7_2();System.out.println(\"main begin t1 isAlive=\" + c.isAlive());c.setName(\"A\");c.start();System.out.println(\"main end t1 isAlive=\" + c.isAlive());}
执行结果：
Mythread7_2---beginThread.currentThread().getName()=mainThread.currentThread().isAlive()=truethis.getName()=Thread-0this.isAlive()=falseMythread7_2---endmain begin t1 isAlive=falserun---beginThread.currentThread().getName()=AThread.currentThread().isAlive()=truethis.getName()=Athis.isAlive()=truerun---endmain end t1 isAlive=false
可以看出：只有在当前实例对象调用了start方法时，this.isAlive()才返回true。
3：interrupt
/*** Interrupts this thread.** <p> Unless the current thread is interrupting itself, which is* always permitted, the {@link #checkAccess() checkAccess} method* of this thread is invoked, which may cause a {@link* SecurityException} to be thrown.** <p> If this thread is blocked in an invocation of the {@link* Object#wait() wait()}, {@link Object#wait(long) wait(long)}, or {@link* Object#wait(long, int) wait(long, int)} methods of the {@link Object}* class, or of the {@link #join()}, {@link #join(long)}, {@link* #join(long, int)}, {@link #sleep(long)}, or {@link #sleep(long, int)},* methods of this class, then its interrupt status will be cleared and it* will receive an {@link InterruptedException}.** <p> If this thread is blocked in an I/O operation upon an {@link* java.nio.channels.InterruptibleChannel InterruptibleChannel}* then the channel will be closed, the thread\'s interrupt* status will be set, and the thread will receive a {@link* java.nio.channels.ClosedByInterruptException}.** <p> If this thread is blocked in a {@link java.nio.channels.Selector}* then the thread\'s interrupt status will be set and it will return* immediately from the selection operation, possibly with a non-zero* value, just as if the selector\'s {@link* java.nio.channels.Selector#wakeup wakeup} method were invoked.** <p> If none of the previous conditio24a7ns hold then this thread\'s interrupt* status will be set. </p>** <p> Interrupting a thread that is not alive need not have any effect.** @throws SecurityException* if the current thread cannot modify this thread** @revised 6.0* @spec JSR-51*/public void interrupt() {if (this != Thread.currentThread())checkAccess();synchronized (blockerLock) {Interruptible b = blocker;if (b != null) {interrupt0(); // Just to set the interrupt flagb.interrupt(this);return;}}interrupt0();}
interrupt并不会立刻停止线程，interrupt0的作用仅仅是为当前线程打一个中断的标志。
4：isInterrupted
/*** Tests whether this thread has been interrupted. The <i>interrupted* status</i> of the thread is unaffected by this method.** <p>A thread interruption ignored because a thread was not alive* at the time of the interrupt will be reflected by this method* returning false.** @return <code>true</code> if this thread has been interrupted;* <code>false</code> otherwise.* @see #interrupted()* @revised 6.0*/public boolean isInterrupted() {return isInterrupted(false);}
测试线程是否已经中断，但不清除状态标识。这个和interrupted()方法区别就是不清除状态标识。
参考文献
1：《Java并发编程的艺术》
2：《Java多线程编程核心技术》
