我对线程的多个方法的理解

[b]首先public class Thread
extends Objectimplements Runnable[/b]

static int MAX_PRIORITY
线程可以具有的最高优先级。
static int MIN_PRIORITY
线程可以具有的最低优先级。
static int NORM_PRIORITY
分配给线程的默认优先级。

[b]它的主要方法[/b]
void interrupt() //中断线程。
static boolean interrupted() //测试当前线程是否已经中断。
boolean isAlive()//测试线程是否处于活动状态。
boolean isDaemon() //测试该线程是否为守护线程。
boolean isInterrupted() //测试线程是否已经中断。
void join() //等待该线程终止。
run()//如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回
static void sleep(long millis)//在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。
void start()// 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
void stop()// 过时
suspend()//已过时。
resume()// 已过时。
destroy()//已过时。
yield()//暂停当前正在执行的线程对象，并执行其他线程。

线程运行的状态图如下:

[img]http://dl.iteye.com/upload/attachment/239432/3ad4a4e8-2432-30f1-b5a7-fbaeee46b5de.jpg[/img]


1.start()是启动一个线程。
2.join()是直到执行完（或强制执行一段时间）当前的线程后才往下执行主线程或其他的线程
3.stop()是停止当前的线程。

4.阻塞线程比较多
sleep() 方法：sleep() 允许 指定以毫秒为单位的一段时间作为参数，它使得线程在指定的时间内进入阻塞状态，不能得到CPU 时间，指定的时间一过，线程重新进入可执行状态。可能给其他线程执行的机会（自私，睡着了，不释放锁，时间到了才放锁）

suspend() 和 resume() 方法：两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的resume() 被调用，才能使得线程重新进入可执行状态。

yield() 方法：yield() 使得线程放弃当前分得的 CPU 时间，但是不使线程阻塞，即线程仍处于可执行状态，随时可能再次分得 CPU 时间。调用 yield() 的效果等价于调度程序认为该线程已执行了足够的时间从而转到另一个线程。不过yield()只能使同等级别的线程获取执行的机会（公平竞争，释放大家再次选举）。而sleep(1000)使同级别或不同级别的都有可能。


wait() 和 notify() 和notifyAll()方法是Object中定义的方法：
必须在synchronized代码块中使用，在synchronized代码被执行期间，线程可以调用对象的wait()方法，释放对象的锁标志，进入等待的状态，并且可以调用notify()或者notifyAll()方法通知正在等待的其他线程。notify()通知的是等待队列中的第一个线程，notifyAll()通知的是等待队列中的所有数量。
几个方法配套使用，wait() 使得线程进入阻塞状态，它有两种形式，一种允许 指定以毫秒为单位的一段时间作为参数，另一种没有参数，前者当对应的 notify() 被调用或者超出指定时间时线程重新进入可执行状态，后者则必须对应的 notify() 被调用。

其中wait()和sleep()方法的区别：

wait()在object类里定义；sleep()在Thread类里定义。

wait()方法只能放在同步方法或同步块中，表示资源同步时，线程需要等待。

sleep()方法可放在任何位置，表示当前线程睡眠。

wait()方法会释放对象锁；sleep()不会释放对象锁。

wait()方法要等待唤醒之后，线程才会继续执行。

sleep()则是休眠一段时间,线程自动恢复执行.

sleep()必须捕获异常，而wait()，notify()和notifyAll()不需要捕获异常


[b]notify()和notifyAll()的区别[/b]

notify() 方法导致解除阻塞的线程是从因调用该对象的 wait() 方法而阻塞的线程中随机选取的，我们无法预料哪一个线程将会被选择，所以编程时要特别小心，避免因这种不确定性而产生问题。
notifyAll() 方法将把因调用该对象的 wait() 方法而阻塞的所有线程一次性全部解除阻塞。当然，只有获得锁的那一个线程才能进入可执行状态。


[b]看join的例子：强制执行子线程完毕再执行主线程[/b]

public class Test extends Thread {

public static int count=1;
public void run(){
for(int i=0;i<5;i++){
count++;
}
}
/**
* @param args
* @throws InterruptedException
*/
public static void main(String[] args) throws InterruptedException {
// TODO Auto-generated method stub
Test t=new Test();
t.start();
//t.join();//没有这句话输出是1，有这句话输出6
//t.join(1);//等待该线程终止的时间最长为1毫秒。输出就不一定是6，可能是5或是4等等
System.out.println(Test.count);
}

}

[b]看一个yield的例子[/b]

public class TestThread3 extends Thread {

public void run(){
for(int i=0;i<10;i++){
if(i==5 && Thread.currentThread().getName().equals("test1")){
Thread.yield();
}
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
TestThread3 t1=new TestThread3();
TestThread3 t2=new TestThread3();
Thread test1=new Thread(t1,"test1");
Thread test2=new Thread(t2,"test2");
//不加则会使执行机会交给test2,否则知道执行完test1才执行test2（同时说明该方法不会使不同的优先级的线程有执行的机会）
//test1.setPriority(Thread.MAX_PRIORITY);
//test2.setPriority(Thread.MIN_PRIORITY);
test1.start();
test2.start();
}

}