（94）多线程实现方式1
最后更新于：2022-04-01 11:00:54
## Java编程那些事儿94——多线程实现方式1
陈跃峰
出自：[http://blog.csdn.net/mailbomb](http://blog.csdn.net/mailbomb)
### 12.2 多线程实现方式
线程的概念虽然比较复杂，但是在Java语言中实现线程却比较简单，只需要按照Java语言中对于线程的规定进行编程即可。
在实现线程编程时，首先需要让一个类具备多线程的能力，继承Thread类或实现Runnable接口的类具备多线程的能力，然后创建线程对象，调用对应的启动线程方法开始执行即可实现多线程编程。
在一个程序中可以实现多个线程，多线程编程指在同一个程序中启动了两个或两个以上的编程形式。当启动的线程数量比较多时，对于系统资源的要求比较多，所以程序支持的最大线程数量和计算机的硬件配置相关。
在实际实现线程时，Java语言提供了三种实现方式：
1、 继承Thread类
2、 实现Runnable接口
3、 使用Timer和TimerTask组合
下面依次介绍每种实现方式的代码编写，以及各种实现之间的区别比较。
### 12.2.1 继承Thread类
如果一个类继承了Thread类，则该类就具备了多线程的能力，则该类则可以以多线程的方式进行执行。
但是由于Java语言中类的继承是单重继承，所以该方式受到比较大的限制。
下面以一个简单的示例介绍该种多线程实现方式的使用以及启动线程的方式。示例代码如下所示：
~~~
/**
* 以继承Thread的方式实现线程
*/
public class FirstThread extends Thread{
public static void main(String[] args) {
//初始化线程
FirstThread ft = new FirstThread();
//启动线程
ft.start();
try{
for(int i = 0;i < 10;i++){
//延时1秒
Thread.sleep(1000);
System.out.println("main:" + i);
}
}catch(Exception e){}
}
public void run(){
try{
for(int i = 0;i < 10;i++){
//延时1秒
Thread.sleep(1000);
System.out.println("run:" + i);
}
}catch(Exception e){}
}
}
~~~
在该程序中，通过使FirstThread继承Thread类，则FirstThread类具备了多线程的能力，按照Java语言线程编程的规定，线程的代码必须书写在run方法内部或者在run方法内部进行调用，在示例的代码中的run方法实现的代码作用是每隔1秒输出一行文字。换句话说，run方法内部的代码就是自定义线程代码，或者说，自定义线程的代码必须书写在run方法的内部。
在执行FirstThread类时，和前面的执行流程一样。当执行FirstThread类时，Java虚拟机将开启一个系统线程来执行该类的main方法，main方法的内部代码按照顺序结构进行执行，首先执行线程对象的初始化，然后执行调用start方法。该行代码的作用是启动线程，在执行start方法时，不阻塞程序的执行，start方法的调用立刻返回，Java虚拟机以自己的方式启动多线程，开始执行该线程对象的run方法。同时系统线程的执行流程继续按照顺序执行main方法后续的代码，执行main方法内部的输出。
这样，在FirstThread执行时，就有了两个同时执行的流程：main流程和自定义run方法流程，换句专业点的话来说，就是该程序在执行时有两个线程：系统线程和自定义线程。这个同时执行可以从该程序的执行结果中获得更加直接的证明。
该程序的执行结果为：
run:0
main:0
main:1
run:1
main:2
run:2
main:3
run:3
main:4
run:4
main:5
run:5
main:6
run:6
main:7
run:7
main:8
run:8
main:9
run:9
从执行结果可以看到两个线程在同时执行，这将使我们进入多线程编程的时代，进入并发编程的领域，体会神奇的多线程编程的魔力。
由于两个线程中的延迟时间——1秒，是比较长的，所以看到的结果是线程规律执行的，其实真正的线程执行顺序是不能直接保证的，系统在执行多线程程序时只保证线程是交替执行的，至于那个线程先执行那个线程后执行，则无法获得保证，需要书写专门的代码才可以保证执行的顺序。
其实，上面的代码可以简化，简化以后的代码为：
~~~
/**
* 以继承Thread的方式实现线程2
* 使用方法简化代码
*/
public class SecondThread extends Thread{
public static void main(String[] args) {
//初始化线程
SecondThread ft = new SecondThread();
//启动线程
ft.start();
print("main:");
}
public void run(){
print("run:");
}
private static void print(String s){
try{
for(int i = 0;i < 10;i++){
//延时1秒
Thread.sleep(1000);
System.out.println(s + i);
}
}catch(Exception e){}
}
}
~~~
在该示例代码中，将重复的代码组织称print方法，分别在main方法和run方法内部调用该方法。需要特别强调的是，在run方法内部调用的方法，也会以多线程多线程的方式被系统执行，这样更加方便代码的组织。
其实在实际实现时，还可以把线程以单独类的形式出现，这样实现的代码如下所示：
~~~
/**
* 测试类
*/
public class Test {
public static void main(String[] args) {
//初始化线程
ThirdThread ft = new ThirdThread();
//启动线程
ft.start();
try{
for(int i = 0;i < 10;i++){
//延时1秒
Thread.sleep(1000);
System.out.println("main:" + i);
}
}catch(Exception e){}
}
}
/**
* 以继承Thread类的方式实现多线程3
* 以单独类的实现组织代码
*/
public class ThirdThread extends Thread {
public void run(){
try{
for(int i = 0;i < 10;i++){
//延时1秒
Thread.sleep(1000);
System.out.println("run:" + i);
}
}catch(Exception e){}
}
}
~~~
在该示例代码中，ThirdThread类是一个单独的线程类，在该类的run方法内部实现线程的逻辑，使用该种结构符合面向对象组织代码的方式。需要启动该线程时，和前面启动的方式一致。
一个类具备了多线程的能力以后，可以在程序中需要的位置进行启动，而不仅仅是在main方法内部启动。
对于同一个线程类，也可以启动多个相同的线程，例如以ThirdThread类为例，启动两次的代码为：
~~~
ThirdThread t1 = new ThirdThread();
t1.start();
ThirdThread t2 = new ThirdThread();
t2.start();
~~~
而下面的代码是错误的
~~~
ThirdThread t1 = new ThirdThread();
t1.start();
t1.start(); //同一个线程不能启动两次
~~~
当自定义线程中的run方法执行完成以后，则自定义线程将自然死亡。而对于系统线程来说，只有当main方法执行结束，而且启动的其它线程都结束以后，才会结束。当系统线程执行结束以后，则程序的执行才真正结束。
总之，继承Thread类可以使该类具备多线程的能力，需要启动该线程时，只需要创建该类的对象，然后调用该对象中的start方法，则系统将自动以多线程的发那个是执行该对象中的run方法了。
虽然该种方式受到Java语法中类的单重继承的限制，但是在实际的项目中还是获得了比较广泛的使用，是一种最基本的实现线程的方式。