多线程实现方式---实现Runnable接口
多线程实现方式---实现Runnable接口
一个类如果需要具备多线程的能力，也可以通过实现java.lang.Runnable接口进行实现。按照Java语言的语法，一个类可以实现任意多个接口，所以该种实现方式在实际实现时的通用性要比前面介绍的方式好一些。
使用实现Runnable接口实现多线程的示例代码如下：
/**
* 测试类
*/
public class Test2 {
public static void main(String[] args) {
//创建对象
MyRunnable mr = new MyRunnable();
Thread t = new Thread(mr);
//启动
t.start();
try{
for(int i = 0;i < 10;i++){
Thread.sleep(1000);
System.out.println("main:" + i);
}
}catch(Exception e){}
}
}
/**
* 使用实现Runnable接口的方式实现多线程
*/
public class MyRunnable implements Runnable {
public void run() {
try{
for(int i = 0;i < 10;i++){
Thread.sleep(1000);
System.out.println("run:" + i);
}
}catch(Exception e){}
}
}
该示例代码实现的功能和前面实现的功能相同。在使用该方式实现时，使需要实现多线程的类实现Runnable，实现该接口需要覆盖run方法,然后将需要以多线程方式执行的代码书写在run方法内部或在run方法内部进行调用。
在需要启动线程的地方，首先创建MyRunnable类型的对象，然后再以该对象为基础创建Thread类的对象，最后调用Thread对象的start方法即可启动线程。代码如下：
//创建对象
MyRunnable mr = new MyRunnable();
Thread t = new Thread(mr);
//启动
t.start();
在这种实现方式中，大部分和前面介绍的方式类似，启动的代码稍微麻烦一些。这种方式也是实现线程的一种主要方式。
12.2.3使用Timer和TimerTask组合
最后一种实现多线程的方式，就是使用java.util包中的Timer和TimerTask类实现多线程，使用这种方式也可以比较方便的实现线程。
在这种实现方式中，Timer类实现的是类似闹钟的功能，也就是定时或者每隔一定时间触发一次线程。其实，Timer类本身实现的就是一个线程，只是这个线程是用来实现调用其它线程的。而TimerTask类是一个抽象类，该类实现了Runnable接口，所以按照前面的介绍，该类具备多线程的能力。
在这种实现方式中，通过继承TimerTask使该类获得多线程的能力，将需要多线程执行的代码书写在run方法内部，然后通过Timer类启动线程的执行。
在实际使用时，一个Timer可以启动任意多个TimerTask实现的线程，但是多个线程之间会存在阻塞。所以如果多个线程之间如果需要完全独立运行的话，最好还是一个Timer启动一个TimerTask实现。
使用该种实现方式实现的多线程示例代码如下：
import java.util.*;
/**
* 测试类
*/
public class Test3 {
public static void main(String[] args) {
//创建Timer
Timer t = new Timer();
//创建TimerTask
MyTimerTask mtt1 = new MyTimerTask("线程1：");
//启动线程
t.schedule(mtt1, 0);
}
}
import java.util.TimerTask;
/**
* 以继承TimerTask类的方式实现多线程
*/
public class MyTimerTask extends TimerTask {
String s;
public MyTimerTask(String s){
this.s = s;
}
public void run() {
try{
for(int i = 0;i < 10;i++){
Thread.sleep(1000);
System.out.println(s + i);
}
}catch(Exception e){}
}
}
在该示例中，MyTimerTask类实现了多线程，以多线程方式执行的代码书写在该类的run方法内部，该类的功能和前面的多线程的代码实现类似。
而在该代码中，启动线程时需要首先创建一个Timer类的对象，以及一个MyTimerTask线程类的兑现，然后使用Timer对象的schedule方法实现，启动线程的代码为：
//创建Timer
Timer t = new Timer();
//创建TimerTask
MyTimerTask mtt1 = new MyTimerTask("线程1：");
//启动线程
t.schedule(mtt1, 0);
其中schedule方法中的第一个参数mtt1代表需要启动的线程对象，而第二个参数0则代表延迟0毫秒启动该线程，也就是立刻启动。
由于schedule方法比较重要，下面详细介绍一下Timer类中的四个schedule方法：
1、 public void schedule(TimerTask task,Date time)
该方法的作用是在到达time指定的时间或已经超过该时间时执行线程task。例如假设t是Timer对象，task是需要启动的TimerTask线程对象，后续示例也采用这种约定实现，则启动线程的示例代码如下：
Date d = new Date(2009-1900,10-1,1,10,0,0);
t. schedule(task,d);
则该示例代码的作用是在时间达到d指定的时间或超过该时间(例如2009年10月2号)时，启动线程task。
2、 public void schedule(TimerTask task, Date firstTime, long period)
该方法的作用是在时间到达firstTime开始，每隔period毫秒就启动一次task指定的线程。示例代码如下：
Date d = new Date(2009-1900,10-1,1,10,0,0);
t. schedule(task,d,20000);
该示例代码的作用是当时间达到或超过d指定的时间以后，每隔20000毫秒就启动一次线程task，这种方式会重复触发线程。
3、 public void schedule(TimerTask task,long delay)
该方法和第一个方法类似，作用是在执行schedule方法以后delay毫秒以后启动线程task。示例代码如下：
t. schedule(task,1000);
该示例代码的作用是在执行该行启动代码1000毫秒以后启动一次线程task。
4、 public void schedule(TimerTask task,long delay,long period)
该方法和第二个方法类似，作用是在执行schedule方法以后delay毫秒以后启动线程task，然后每隔period毫秒重复启动线程task。
例外需要说明的是Timer类中启动线程还包含两个scheduleAtFixedRate方法，这两个方法的参数和上面的第二个和第四个一致，其作用是实现重复启动线程时的精确延时。对于schedule方法来说，如果重复的时间间隔是1000毫秒，则实际的延迟时间是1000毫秒加上系统执行时消耗的时间，例如为5毫秒，则实际每轮的时间间隔为1005毫秒。而对于scheduleAtFixedRate方法来说，如果设置的重复时间间隔为1000毫秒，系统执行时消耗的时间为5毫秒，则延迟时间就会变成995毫秒，从而保证每轮间隔为1000毫秒。
介绍完了schedule方法以后，让我们再来看一下前面的示例代码，如果在测试类中启动两个MyTimerTask线程，一种实现的代码为：
import java.util.Timer;
/**
* 测试类
*/
public class Test4 {
public static void main(String[] args) {
//创建Timer
Timer t = new Timer();
//创建TimerTask
MyTimerTask mtt1 = new MyTimerTask("线程1：");
MyTimerTask mtt2 = new MyTimerTask("线程2：");
//启动线程
System.out.println("开始启动");
t.schedule(mtt1, 1000);
System.out.println("启动线程1");
t.schedule(mtt2, 1000);
System.out.println("启动线程2");
}
}
在该示例代码中，使用一个Timer对象t依次启动了两个MyTimerTask类型的对象mtt1和mtt2。而程序的执行结果是：
开始启动
启动线程1
启动线程2
线程1：0
线程1：1
线程1：2
线程1：3
线程1：4
线程1：5
线程1：6
线程1：7
线程1：8
线程1：9
线程2：0
线程2：1
线程2：2
线程2：3
线程2：4
线程2：5
线程2：6
线程2：7
线程2：8
线程2：9
从程序的执行结果可以看出，在Test4类中mtt1和mtt2都被启动，按照前面的schedule方法介绍，这两个线程均会在线程启动以后1000毫秒后获得执行。但是从实际执行效果却可以看出这两个线程不是同时执行的，而是依次执行，这主要是因为一个Timer启动的多个TimerTask之间会存在影响，当上一个线程未执行完成时，会阻塞后续线程的执行，所以当线程1执行完成以后线程2才获得了执行。
如果需要线程1和线程2获得同时执行，则只需要分别使用两个Timer启动TimerTask线程即可，启动的示例代码如下：
import java.util.Timer;
/**
* 测试类
*/
public class Test5 {
public static void main(String[] args) {
//创建Timer
Timer t1 = new Timer();
Timer t2 = new Timer();
//创建TimerTask
MyTimerTask mtt1 = new MyTimerTask("线程1：");
MyTimerTask mtt2 = new MyTimerTask("线程2：");
//启动线程
System.out.println("开始启动");
t1.schedule(mtt1, 1000);
System.out.println("启动线程1");
t2.schedule(mtt2, 1000);
System.out.println("启动线程2");
}
}
在该示例中，分别使用两个Timer对象t1和t2，启动两个TimerTask线程对象mtt1和mtt2，两者之间不互相干扰，所以达到了同时执行的目的。
在使用上面的示例进行运行时，由于Timer自身的线程没有结束，所以在程序输出完成以后程序还没有结束，需要手动结束程序的执行。例如在Eclipse中可以点击控制台上面的红色“Teminate”按钮结束程序。
12.2.4 小结
关于线程的三种实现方式，就简单的介绍这么多。其实无论那种实现方式，都可以实现多线程，在语法允许的前提下，可以使用任何一种方式实现。比较而言，实现Runnable接口方式要通用一些。
只是从语法角度介绍线程的实现方式，还是无法体会到线程实现的奥妙，下面将通过几个简单的示例来体会线程功能的强大，并体会并发编程的神奇，从而能够进入并发编程的领域发挥技术的优势。
