线程的状态转换如下所示：

分析可知，线程启动之后处于就绪状态，要等待CPU进行调度，并不是立刻启动的。

线程的常用方法：

方法功能
currentThread()获得当前运行的线程
getName()获得当前线程的名称
setName()设置线程的名称
isAlive()判断线程是否还"活"着，即线程是否还未终止
sleep()将当前线程睡眠指定的毫秒数
join()调用A线程的该方法，将当前线程与A线程"合并"，即等待A线程结束，再回复当前线程的运行。

 setName():

线程的名字一般在启动线程前设置，但也允许为已经运行的线程设置名字。允许两个Thread对象有相同的名字，但为了理解方便，应该尽量避免这种情况。

代码示例：


  
  1. class Kirl implements Runnable  
  2. {  
  3.     public void printText()  
  4.     {  
  5.         for(int i = 0;i < 5;i++)  
  6.         {  
  7.             System.out.println(Thread.currentThread().getName() + "->" + i);  
  8.         }  
  9.     }  
  10.     public void run()  
  11.     {  
  12.         printText();  
  13.     }  
  14. }  
  15. public class TestThread {  
  16.     /**  
  17.      * @param args  
  18.      */ 
  19.     public static void main(String[] args) {  
  20.         // TODO Auto-generated method stub  
  21.         Kirl k1 = new Kirl();  
  22.         Thread t1 = new Thread(k1,"Thread1");  
  23.         t1.start();  
  24.         k1.printText();  
  25.     }  
  26. } 
 
  
输出结果为：
 
  
main->0
 Thread1->0
 Thread1->1
 Thread1->2
 Thread1->3
 Thread1->4
 main->1
 main->2
 main->3
 main->4
 
  
由以上程序分析可知，main方法也是一个线程，所以之前的所有程序都是基于多线程的运行机制，在main方法中通过对象.方法调用的一切代码都是主线程。
 
  
isAlive():
 
  
start()方法通知线程规划器这个新线程已准备就绪，而且应当在规划器的最早方便时间调用它的run()方法。那么isAlive()方法的作用就是用来测试线程是否已经启动而且仍然启动。
 
  
示例代码如下：
 
  

  
  1. class Kirl implements Runnable  
  2. {  
  3.     public void printText()  
  4.     {  
  5.         System.out.println(Thread.currentThread().getName());  
  6.     }  
  7.     public void run()  
  8.     {  
  9.         printText();  
  10.     }  
  11. }  
  12. public class TestThread {  
  13.  
  14.     /**  
  15.      * @param args  
  16.      * @throws Exception   
  17.      */ 
  18.     public static void main(String[] args) throws Exception {  
  19.         // TODO Auto-generated method stub  
  20.         Kirl k1 = new Kirl();  
  21.         Thread t1 = new Thread(k1,"Thread1");  
  22.         System.out.println("Before start thread:" + t1.isAlive());  
  23.         t1.start();  
  24.         System.out.println("After start thread:" + t1.isAlive());  
  25.         Thread.sleep(3000);  
  26.         System.out.println("After sleep thread:" + t1.isAlive());  
  27.     }  
  28. } 
 
  
输出结果为：
 
  
Before start thread:false
 After start thread:true
 Thread1
 After sleep thread:false
 
  
综上所述，isAlive方法在线程执行之后进行判断时，结果没有固定的内容，因为线程有可能优先执行完，也有可能在最后执行完。
 
  
join():
 
  
在线程中使用join()方法，用于强制某一线程运行。
 
  
代码示例如下：
 
  

  
  1. class Kirl implements Runnable  
  2. {  
  3.     public void printText()  
  4.     {  
  5.         for(int i = 0;i < 10;i++)  
  6.         {  
  7.             System.out.println(Thread.currentThread().getName() + "->" + i);  
  8.         }  
  9.     }  
  10.     public void run()  
  11.     {  
  12.         printText();  
  13.     }  
  14. }  
  15. public class TestThread {  
  16.     /**  
  17.      * @param args  
  18.      * @throws Exception   
  19.      */ 
  20.     public static void main(String[] args) throws Exception {  
  21.         // TODO Auto-generated method stub  
  22.         Kirl k1 = new Kirl();  
  23.         Thread t1 = new Thread(k1,"Thread1");  
  24.         t1.start();  
  25.         for(int i = 0;i < 10;i++)  
  26.         {  
  27.             if(i == 5)  
  28.             {  
  29.                 t1.join();  
  30.             }  
  31.             System.out.println(Thread.currentThread().getName() + "->" + i);  
  32.         }  
  33.     }  
  34. } 
 
  
输出结果为：
 
  
main->0
 main->1
 main->2
 main->3
 main->4
 Thread1->0
 Thread1->1
 Thread1->2
 Thread1->3
 Thread1->4
 Thread1->5
 Thread1->6
 Thread1->7
 Thread1->8
 Thread1->9
 main->5
 main->6
 main->7
 main->8
 main->9
 由输出结果可得结论，当运行到i=5时，Thread1线程便开始一直执行，直到结束，main线程才可以执行。join()方法指一个线程必须运行完成之后其它的线程才可以继续运行，表示强制性运行。