线程的创建和启动

Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每条线程的作用是完成一定的任务，

实际上就是执行一段程序流（一段顺序执行的代码）。Java使用run方法来封装这样一段程序流。

继承Thread类创建线程类

通过继承Thread类来创建并启动多线程的步骤如下：
1、定义Thread类的子类，并重写该类的run方法，该run方法的方法体就是代表了线程需要完成的任务。因此，我们经常
把run方法称为线程执行体。
2、创建Thread子类的实例，即创建了线程对象。
3、用线程对象的start方法来启动线程。
下面程序示范了通过继承Thread类来创建、并启动多线程的程序。

[java]  view plain copy

1. public class FirstThread extends Thread{  
2.   
3.     private int i;  
4.       
5.     /** 
6.      * 重写run方法，run方法的方法体就是线程执行体 
7.      */  
8.     @Override  
9.     public void run() {  
10.         for(;i< 100;i++){  
11.             //当线程类继承Thread类时，可以直接调用getName()方法来返回当前线程的名  
12.             //如果想获取当前线程，直接使用this即可  
13.             //Thread对象的getName()返回当前线程的名字  
14.             System.out.println(getName() + " " + i);  
15.         }  
16.     }  
17.     public static void main(String[] args) {  
18.         for(int i = 0;i<100;i++){  
19.             //调用Thread的currentThread方法来获取当前线程  
20.             System.out.println(Thread.currentThread().getName() + " " +i);  
21.             if(i == 20){  
22.                 //创建、并启动第一条线程  
23.                 new FirstThread().start();  
24.                 //创建、并启动第二条线程  
25.                 new FirstThread().start();  
26.               
27.             }  
28.         }  
29.     }  
30. }  

上面程序中FirstThread类继承了Thread类，并实现了run方法，运行的结果如下图：

虽然上面程序只显示地创建并启动了两条线程，但实际上程序至少有3条线程：程序显示创建的2个子线程和主线程。前面
已经提到了， 当Java程序开始运行后，程序至少会创建一条主线程，主线程的线程执行体不是由run方法来确定的，而是由main
方法来确定：main方法的方法体代表主线程的线程执行体。 
除此之外，上面程序还用到了线程的两个方法：
== Thread.currentThread():currentThread是Thread类的静态方法，该方法总是返回当前正在执行的线程对象。
== getName():该方法是Thread的实例方法 
程序可以通过setName(String name)方法为主线程设置名字，也可以通过getName()方法返回指定线程的名字。在默认
情况下，主线程的名字为main，用户启动的多线程的名字依次为Thread-0、Thread-1、Thread-2....Thread-n等。
从上图可以看出，Thread-0和Thread-1两条线程输出的i变量不连续，注意i变量时FirstThread的实例属性，而不是局部
变量，但因为程序每次创建线程对象都需要创建一个FirstThread对象，所以Thread-0和Thread-1不能共享该实例属性。
注意：使用继承Thread类的方法来创建线程类，多线程之间无法共享线程类的实例变量。

  实现Runnable接口创建线程类

实现Runnable接口来创建并启动多条线程的步骤如下：
1、定义Runnable接口的实现类，并重写该接口的run方法，该run方法的方法体同样是该线程的线程执行体。
2、创建Runnable实现类的实例，并以此实例作为的Thread的target来创建Thread对象，该Thread对象才是真正的线程
对象。代码如下所示：

[java]  view plain copy

1. //创建Runnable实现类的对象  
2. SecondThread st = new SecondThread();  
3. //以Runnable实现类的对象作为Thread的target来创建Thread对象，即线程对象  
4. new Thread(st);  

也可以在创建Thread对象时为该Thread对象指定一个名字，代码如下所示：

[java]  view plain copy

1. //创建Thread对象时指定target和新线程的名字  
2. new Thread(st,"新线程1");  

提示：
Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run方法仅作为线程执行体。而实际的线程对象
依然是Thread实例，只是该Thread线程负责执行其target的run方法。。Java语言的Thread必须使用Runnable对象的run方法
作为线程执行体；当C#可以把任何对象的任意方法来作为线程执行体。 
3、调用线程对象的start方法来启动该线程。

下面程序示范了通过实现Runnable接口来创建并启动多线程的程序。

[java]  view plain copy

1. public class SecondThread implements Runnable{  
2.   
3.     private int i;  
4.       
5.     @Override  
6.     public void run() {  
7.         for(;i<100;i++){  
8.             //当线程类实现Runnable接口时，如果想获取当前线程，只能用Thread.currentThread()方法  
9.             System.out.println(Thread.currentThread().getName() + " " +i);  
10.         }  
11.     }  
12.       
13.     public static void main(String[] args) {  
14.         for(int i=0;i<100;i++){  
15.             System.out.println(Thread.currentThread().getName() + " " + i);  
16.             if(i == 20){  
17.                 SecondThread st = new SecondThread();  
18.                 //通过new Thread(target,name)方法来创建新线程  
19.                 new Thread(st, "新线程1").start();  
20.                 new Thread(st, "新线程2").start();  
21.             }  
22.         }  
23.     }  
24.   
25. }  

对比FirstThread中的run方法个SecondThread中的run方法不难发现；使用继承Thread时获得当前线程对象比较简单
，直接使用this就可以了；但使用Runnable接口时要获得当前线程对象必须使用Thread.currentThread()方法。除此之外
对比FirstThread和SecondThread中创建线程对象的方式有所区别：前者直接创建的Thread子类即可代表线程对象；后者
创建的Runnable对象只能作为线程对象的target。
运行上面的程序如下图：

从图中的灰色区域可以看出，两条子线程的i变量时连续的，也就是采用Runnable接口的方式来创建的多条线程可以共享
线程类的实例属性。这是因为在这种方式下，程序所创建的Runnable对象只是线程的target，而多条线程可以共享同一个
target，所以多条线程可以共享同一个线程类（实际上应该是线程的target类）的实例属性。 

两种方式所创建线程的对比

通过继承Thread类或实现Runnable接口都可以实现多线程。但两种方式存在一定的差别，相比之下两种方式的主要差别
如下：
采用实现Runnable接口方式实现的多线程：
== 多线程类知识实现了Runnable接口，还可以继承其他类
== 在这种方式下，可以多个线程共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而
可以讲CPU、代码和数据分开，形成清晰的模型，较好的体现了面向对象的思想。
== 劣势是：编程稍稍复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法。
采用继承Thread类方式的多线程：
劣势是：因为线程类以及继承了Thread类，不能再继承其他父类
优势是：编写简单，如果需要访问当前线程，无须使用Thread.currentThread()方法，直接使用this即可获得当前线程。