请问，线程的优先级有哪些值?（如Thread.setPriority(a),----a的取值范围是多少？）
还有就是为什么在执行t2.join()的时候，线程1并没有等待线程2终止再执行，而是互相争夺CPU的执行权？

1. package com.zzh.bean;
   
2. 
   
3. class MyThreadDemo implements Runnable{
   
4.         public void run(){
   
5.                 for(int i=0;i<5;i++)
   
6.                 {        
   
7.                 System.out.println(Thread.currentThread().getName()+"----"+i);
   
8.                 try {
   
9.                         Thread.sleep(300);
   
10.                 } catch (InterruptedException e1) {
    
11.                         // TODO Auto-generated catch block
    
12.                         e1.printStackTrace();
    
13.                 }
    
14.         }}
    
15. }
    
16. public class ThreadTestDemo {
    
17.         public static void main(String args[]) throws InterruptedException{
    
18.                 Thread t1=new Thread(new MyThreadDemo(),"Thread-1");
    
19.                 t1.setPriority(5);
    
20.                 t1.start();        
    
21.                 Thread t2=new Thread(new MyThreadDemo(),"Thread—2");
    
22.                 t2.start();
    
23.                 t2.join();                                
    
24.         }
    
25. }
    
26. <font color="red">/*
    
27. * 输出：
    
28. Thread-1
    
29. Thread—2
    
30. Thread-1
    
31. Thread—2
    
32. Thread-1
    
33. Thread—2
    
34. Thread-1
    
35. Thread—2
    
36. Thread-1
    
37. Thread—2
    
38. */</font>
    

复制代码

Java提供了10个优先级，但是这需要操作系统的支持，并不是所有的操作系统都有这么多优先级，一般main线程与其创建的主线程默认都是6。
设置优先级时尽量使用Java提供的静态常量，如：
MAX_PRIORITY
MIN_PRIORITY
NORM_PRIORITY

PS:
      你要看现象的话，多试几次

你在join后面添加一句System.out.println("主线程");   你会发现主线程停了。

二、为什么要用join()方法

主线程生成并起动了子线程，而子线程里要进行大量的耗时的运算(这里可以借鉴下线程的作用)，当主线程处理完其他的事务后，需要用到子线程的处理结果，这个时候就要用到join();方法了。
     摘自：http://www.blogjava.net/jnbzwm/articles/330549.html

(1)优先级有10（1-10）个，老毕说不建议用数字，要用MAX_PRIORITY  MIN_PRIORITY  NORM_PRIORITY 即最大，最小，正常。
(2)你的join()方法理解错误。老毕原话：当A线程执行到了B线程的.join()方法时，A就会等待。等B线程执行完毕，A才会执行。你的代码中main()方法就是A线程。t1和t2没有执行与被执行的关系（读完t1,t1就玩命的执行它的线程，下面代码有main()执行,t2不执行t1才高兴呢）. 所以t2就不满足A线程的条件。
我把你的代码加了个mian()方法。可以发现 t2.join() 是终止了main().
package com.zzh.bean;
class MyThreadDemo implements Runnable{
        public void run(){
                for(int i=0;i<5;i++)
                {        
                System.out.println(Thread.currentThread().getName()+"----"+i);
                try {
                        Thread.sleep(300);
                } catch (InterruptedException e1) {
                        // TODO Auto-generated catch block
                        e1.printStackTrace();
                }
        }}
}
public class ThreadTestDemo {
        public static void main(String args[]) throws InterruptedException{
                Thread t1=new Thread(new MyThreadDemo(),"Thread-1");
                t1.setPriority(5);
                t1.start();        
                Thread t2=new Thread(new MyThreadDemo(),"Thread—2");
                t2.start();
                t2.join();
                                for (int x= 0;x<5 ;x++ )
                                {
                                        System.out.println("hahha");
                                }                               
        }
}
/*
Thread—2----0
Thread-1----0
Thread—2----1
Thread-1----1
Thread-1----2
Thread—2----2
Thread-1----3
Thread—2----3
Thread-1----4
Thread—2----4
hahha
hahha
hahha
hahha
hahha
*/

如果你没有给子线程指定优先级，运行时，谁抢到资源就谁先运行，