isAlive()
测试线程是否处于活动状态，只要线程启动且没有终止，方法返回的就是true。
/** * 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();isDaemon、setDaemon(boolean on)
Java中有两种线程，一种是用户线程，一种是守护线程。守护线程是一种特殊的线程，它的作用是为其他线程的运行提供便利的服务，最典型的应用便是GC线程。如果进程中不存在非守护线程了，那么守护线程自动销毁，因为没有存在的必要，为别人服务，结果服务的对象都没了，当然就销毁了。 关于守护线程，有一个细节注意下，setDaemon(true)必须在线程start()之前。
sleep相当于让线程睡眠，交出CPU，让CPU去执行其他的任务。
但是有一点要非常注意，sleep方法不会释放锁，也就是说如果当前线程持有对某个对象的锁，则即使调用sleep方法，其他线程也无法访问这个对象。看下面这个例子就清楚了：
public class Test { private int i = 10; private Object object = new Object(); public static void main(String[] args) throws Exception { Test test = new Test(); MyThread thread1 = test.new MyThread(); MyThread thread2 = test.new MyThread(); thread1.start(); thread2.start(); } class MyThread extends Thread{ @Override public void run() { System.out.println(Thread.currentThread().getName() + " start the task!"); synchronized (object) { i++; System.out.println("i:"+i); try { System.out.println("线程"+Thread.currentThread().getName()+"进入睡眠状态"); Thread.currentThread().sleep(10000); } catch (InterruptedException e) { // TODO: handle exception } System.out.println("线程"+Thread.currentThread().getName()+"睡眠结束"); i++; System.out.println("i:"+i); } } } } Thread-0 start the task! Thread-1 start the task! i:11 线程Thread-0进入睡眠状态 线程Thread-0睡眠结束 i:12 i:13 线程Thread-1进入睡眠状态 线程Thread-1睡眠结束 i:14 /** * 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;注意，如果调用了sleep方法，必须捕获InterruptedException异常或者将该异常向上层抛出。当线程睡眠时间满后，不一定会立即得到执行，因为此时可能CPU正在执行其他的任务。所以说调用sleep方法相当于让线程进入阻塞状态。 下面进一步展示了当线程在sleep过程中被中断的情况：
public class Test { private int i = 10; private Object object = new Object(); public static void main(String[] args) throws Exception { Test test = new Test(); MyThread thread1 = test.new MyThread(); MyThread thread2 = test.new MyThread(); thread1.start(); thread2.start(); Thread.currentThread().sleep(3000); thread1.interrupt(); } class MyThread extends Thread{ @Override public void run() { System.out.println(Thread.currentThread().getName() + " start the task!"); synchronized (object) { i++; System.out.println("i:"+i); try { System.out.println("线程"+Thread.currentThread().getName()+"进入睡眠状态"); Thread.currentThread().sleep(10000); } catch (InterruptedException e) { // TODO: handle exception System.out.println("interrupted..."); } System.out.println("线程"+Thread.currentThread().getName()+"睡眠结束"); i++; System.out.println("i:"+i); } } } } Thread-0 start the task! Thread-1 start the task! i:11 线程Thread-0进入睡眠状态 interrupted... 线程Thread-0睡眠结束 i:12 i:13 线程Thread-1进入睡眠状态 线程Thread-1睡眠结束 i:14调用yield方法会让当前线程交出CPU权限，让CPU去执行其他的线程。它跟sleep方法类似，同样不会释放锁。但是yield不能控制具体的交出CPU的时间，另外，yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会。
注意，调用yield方法并不会让线程进入阻塞状态，而是让线程重回就绪状态，它只需要等待重新获取CPU执行时间，这一点是和sleep方法不一样的。
假如在main线程中，调用thread.join方法，则main方法会等待thread线程执行完毕或者等待一定的时间。如果调用的是无参join方法，则等待thread执行完毕，如果调用的是指定了时间参数的join方法，则等待一定的时间。
public class Test { public static void main(String[] args) throws Exception { System.out.println("进入线程"+Thread.currentThread().getName()); Test test = new Test(); MyThread thread1 = test.new MyThread(); thread1.start(); try { System.out.println("线程"+Thread.currentThread().getName()+"等待"); thread1.join(); System.out.println("线程"+Thread.currentThread().getName()+"继续执行"); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } class MyThread extends Thread{ @Override public void run() { System.out.println("进入线程"+Thread.currentThread().getName()); try { Thread.currentThread().sleep(5000); } catch (InterruptedException e) { // TODO: handle exception } System.out.println("线程"+Thread.currentThread().getName()+"执行完毕"); } } } 进入线程main 线程main等待 进入线程Thread-0 线程Thread-0执行完毕 线程main继续执行实际上调用join方法是调用了Object的wait方法，这个可以通过查看源码得知：
public final synchronized void join(long millis) throws InterruptedException { long base = System.currentTimeMillis(); long now = 0; if (millis < 0) { throw new IllegalArgumentException("timeout value is negative"); } if (millis == 0) { while (isAlive()) { wait(0); } } else { while (isAlive()) { long delay = millis - now; if (delay <= 0) { break; } wait(delay); now = System.currentTimeMillis() - base; } } }wait方法会让线程进入阻塞状态，并且会释放线程占有的锁，并交出CPU执行权限。由于wait方法会让线程释放对象锁，所以join方法同样会让线程释放对一个对象持有的锁。具体的wait方法使用在后面文章中给出。
interrupt，顾名思义，即中断的意思。单独调用interrupt方法可以使得处于阻塞状态的线程抛出一个异常，也就说，它可以用来中断一个正处于阻塞状态的线程；另外，通过interrupt方法和isInterrupted()方法来停止正在运行的线程。 interrupt()方法的作用实际上是：在线程受到阻塞时抛出一个中断信号，这样线程就得以退出阻塞状态。换句话说，没有被阻塞的线程，调用interrupt()方法是不起作用的。
public class Test { public static void main(String[] args) throws Exception { Test test = new Test(); MyThread thread = test.new MyThread(); thread.start(); try { Thread.currentThread().sleep(2000); } catch (InterruptedException e) { } thread.interrupt(); } class MyThread extends Thread{ @Override public void run() { try { System.out.println("进入睡眠状态"); Thread.currentThread().sleep(10000); System.out.println("睡眠完毕"); } catch (InterruptedException e) { System.out.println("得到中断异常"); } System.out.println("run方法执行完毕"); } } } 进入睡眠状态 得到中断异常 run方法执行完毕从这里可以看出，通过interrupt方法可以中断处于阻塞状态的线程。那么能不能中断处于非阻塞状态的线程呢？直接调用interrupt方法不能中断正在运行中的线程。 但是如果配合isInterrupted()能够中断正在运行的线程，因为调用interrupt方法相当于将中断标志位置为true，那么可以通过调用isInterrupted()判断中断标志是否被置位来中断线程的执行。
import java.io.IOException; public class Test { public static void main(String[] args) throws IOException { Test test = new Test(); MyThread thread = test.new MyThread(); thread.start(); try { Thread.currentThread().sleep(2000); } catch (InterruptedException e) { } thread.interrupt(); } class MyThread extends Thread{ @Override public void run() { int i = 0; while(!isInterrupted() && i<Integer.MAX_VALUE){ System.out.println(i+" while循环"); i++; } } } }但是一般情况下不建议通过这种方式来中断线程，一般会在MyThread类中增加一个属性 isStop来标志是否结束while循环，然后再在while循环中判断isStop的值。
class MyThread extends Thread{ private volatile boolean isStop = false; @Override public void run() { int i = 0; while(!isStop){ i++; } } public void setStop(boolean stop){ this.isStop = stop; } }wait()和notify()、notifyAll()
这三个方法用于协调多个线程对共享数据的存取，所以必须在synchronized语句块内使用。 synchronized关键字用于保护共享数据，阻止其他线程对共享数据的存取，但是这样程序的流程就很不灵活了，如何才能在当前线程还没退出synchronized数据块时让其他线程也有机会访问共享数据呢？此时就用这三个方法来灵活控制。
wait()方法使当前线程暂停执行并释放对象锁标示，让其他线程可以进入synchronized数据块，当前线程被放入对象等待池中。当调用notify()方法后，将从对象的等待池中移走一个任意的线程并放到锁标志等待池中，只有锁标志等待池中线程能够获取锁标志；如果对象等待池中没有线程，则notify()不起作用。 notifyAll()则从对象等待池中移走所有等待那个对象的线程并放到锁标志等待池中。
public final native void wait(long timeout) throws InterruptedException;obj.wait()，当前线程调用对象的wait()方法，当前线程释放对象锁，进入等待队列。依靠notify()/notifyAll()唤醒或者wait(long timeout)timeout时间到自动唤醒。 obj.notify()唤醒在此对象监视器上等待的单个线程，选择是任意性的。notifyAll()唤醒在此对象监视器上等待的所有线程。 注意 这三个方法都是java.lang.Object的方法。 sleep()方法和wait()方法的区别 1.wait与notify方法都是定义在Object类中，而且是final的，因此会被所有的Java类所继承并且无法重写。这两个方法要求在调用时线程应该已经获得了对象的锁，因此对这两个方法的调用需要放在synchronized方法或块当中。当线程执行了wait方法时，它会释放掉对象的锁。
2.另一个会导致线程暂停的方法就是Thread类的sleep方法，它会导致线程睡眠指定的毫秒数，但线程在睡眠的过程中是不会释放掉对象的锁的。
3.notify():唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程，选择是任意性的。
直到当前线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争。
Thread类中的静态方法
Thread类中的静态方法表示操作的线程是”正在执行静态方法所在的代码块的线程”。为什么Thread类中要有静态方法，这样就能对CPU当前正在运行的线程进行操作。下面来看一下Thread类中的静态方法：
1、currentThread() currentThread()方法返回的是对当前正在执行线程对象的引用。
public class MyThread04 extends Thread { static { System.out.println("静态块的打印：" + Thread.currentThread().getName()); } public MyThread04() { System.out.println("构造方法的打印：" + Thread.currentThread().getName()); } public void run() { System.out.println("run()方法的打印：" + Thread.currentThread().getName()); } } public static void main(String[] args) { MyThread04 mt = new MyThread04(); mt.start(); } 静态块的打印：main 构造方法的打印：main run()方法的打印：Thread-0这个例子说明了，线程类的构造方法、静态块是被main线程调用的，而线程类的run()方法才是应用线程自己调用的。
public class MyThread05 extends Thread { public MyThread05() { System.out.println("MyThread5----->Begin"); System.out.println("Thread.currentThread().getName()----->" + Thread.currentThread().getName()); System.out.println("this.getName()----->" + this.getName()); System.out.println("MyThread5----->end"); } public void run() { System.out.println("run----->Begin"); System.out.println("Thread.currentThread().getName()----->" + Thread.currentThread().getName()); System.out.println("this.getName()----->" + this.getName()); System.out.println("run----->end"); } } public static void main(String[] args) { MyThread05 mt5 = new MyThread05(); mt5.start(); } MyThread5----->Begin Thread.currentThread().getName()----->main this.getName()----->Thread-0 MyThread5----->end run----->Begin Thread.currentThread().getName()----->Thread-0 this.getName()----->Thread-0 run----->end“this.XXX()”和”Thread.currentThread().XXX()”的区别。必须要清楚的一点就是：当前执行的Thread(Thread.currentThread())未必就是Thread本身(this)。从这个例子就能看出来：
（1）执行MyThread05构造方法是main，当前线程却是Thread-0
（2）执行run()方法的Thread-0，当前线程也是Thread-0，说明run()方法就是被线程实例去执行的
所以，再强调一下，未必在MyThread05里调用Thread.currentThread()返回回来的线程对象的引用就是MyThread05。
2、sleep(long millis) 3、yield() 4、interrupted() 测试当前线程是否已经中断，执行后具有将状态标识清除为false的功能。换句话说，如果连续两次调用该方法，那么返回的必定是false。
