Java核心技术之多线程的实现java温娉哲-

Java实现多线程的四种方式

1、继承Thread类
2、实现Runnable接口
3、使用Future Task
4、使用Executor框架

继承Thread类和实现Runnable接口是最基本的方式，但有一个共同的缺点：没有返回值。而Future Task解决了这个问题。Executor是JDK提供的一个多线程框架。

Java8创建一个新的执行线程有两种方法：
1、一种是将一个类声明为Thread的子类。这个子类应该重写run 类的方法Thread。然后可以分配并启动子类的实例。
2、另一种创建一个线程是声明实现类Runnable接口。那个类然后实现了run方法。然后可以分配类的实例，在创建Thread时作为参数传递，并启动。
注意：使用继承Thread类创建线程，最大的局限就是不能多继承，所以为了支持多继承，可以采用实现Runnable接口的方式。

继承Thread类实现独立线程单词抄写

模拟一个业务场景：

先来看第一种实现方式：继承Thread类，重写run方法的方式。
下面通过程序来模拟小明抄写单词的任务。小编觉得抄写次数100有点多，为了减轻小明的工作量，下面代码用的都是抄写10次。
1、定义Punishment.java类，存储要抄写的单词，以及剩余抄写次数。

package com.JavaCoding.ManyThread; import lombok.Data; @Data public class Punishment { private int leftCopyCount; private String wordToCopy; public Punishment(int leftCopyCount, String wordToCopy) { this.leftCopyCount = leftCopyCount; //剩余抄写次数 this.wordToCopy = wordToCopy; //要抄写的单词 } } 

2、定义Student.java类，引用Punishment，实现抄写单词的copyWord方法。

package com.JavaCoding.ManyThread_Thread; import com.JavaCoding.ManyThread.Punishment; //1、继承Thread类 public class Student extends Thread { private String name; private Punishment punishment; public Student(String name, Punishment punishment) { //2、调用Thread构造方法，设置threadname super(name); this.name = name; this.punishment = punishment; } public void copyWord(){ int count=0;         String threadName=Thread.currentThread().getName(); while (true){ if(punishment.getLeftCopyCount()>0){ int leftCopyCount=punishment.getLeftCopyCount();                 System.out.println(threadName+"线程-"+name+"抄写"+punishment.getWordToCopy()+"。还要抄写"+--leftCopyCount+"次");                 punishment.setLeftCopyCount(leftCopyCount);                 count++; }else { break; } }         System.out.println(threadName+"线程-"+name+"一共抄写了"+count+"次！"); } //3、重写run方法，调用copyWord public void run(){ copyWord(); } } 

其中Student构造函数传入Punishment，copyWord方法是根据惩罚内容，完成单词抄写的主要逻辑。
copyWord方法中，count变量是计数器，记录抄写的总次数。threadName是本线程的名称，这里通过Thread的静态方法currentThread取得当前线程，然后通过getName方法获取线程名称。
While循环中，当punishment的剩余抄写次数大于0时，执行抄写逻辑，否则抄写任务完成，跳出循环。
3、通过main方法运行，查看运行效果。

package com.JavaCoding.ManyThread_Thread; import com.JavaCoding.ManyThread.Punishment; public class StudentClient { public static void main(String[] args) {         Punishment punishment=new Punishment(10,"internationalization");         Student student=new Student("小明",punishment);         student.start();         System.out.println("Another thread will finish the punishment.main thread is finished"); } } 

start方法是从Thread类继承而来，调用后线程进入就绪状态，等待CPU的调用。而start方法最终会触发执行run方法，在run方法中copyWord被执行。

运行之后的结果显示为：

实现Runnable接口，启动单线程抄写单词

同样的例子，来看一下用实现Runnable接口来实现多线程。
1、定义Student类， 实现Runnable接口

package com.JavaCoding.ManyThread_Runnable; import com.JavaCoding.ManyThread.Punishment; import org.junit.runner.RunWith; public class Student implements Runnable { private  String  name; private Punishment punishment; public Student(String name, Punishment punishment) { this.name = name; this.punishment = punishment; } public void copyWord(){ int count=0;         String threadName=Thread.currentThread().getName(); while (true){ if(punishment.getLeftCopyCount()>0){ int leftCopyCount=punishment.getLeftCopyCount();                 System.out.println(threadName+"线程-"+name+"抄写"+punishment.getWordToCopy()+"。还要抄写"+--leftCopyCount+"次");                 punishment.setLeftCopyCount(leftCopyCount);                 count++; }else { break; } }         System.out.println(threadName+"线程-"+name+"一共抄写了"+count+"次"); } //重写run方法，完成任务 @Override public void run(){ copyWord(); } } 

2、定义一个StudentClient类，main方法运行，查看显示的效果

package com.JavaCoding.ManyThread_Runnable; import com.JavaCoding.ManyThread.Punishment; public class StudentClient { public static void main(String[] args) {         Punishment punishment=new Punishment(10,"internationalization");         Thread xiaoming=new Thread(new Student("小明",punishment),"小明");         xiaoming.start(); } } 

main方法中需要创建一个Thread，把实现了Runnable接口的对象通过构造函数传递进去，Thread构造函数的第二个参数是自定义的thread name。继承Thread类的实现方式中，由于Student是Thread的子类，所以可以直接通过new Student 就可以得到线程对象。最后都是通过调用Thread对象的start方法来启动线程。运行结果和继承Thread的方式结果一样。

继承Thread类和实现Runnable接口 实现多线程的区别

1、继承Thread方式

Student xiaoming=new Student("小明",punishment); xiaoming.start(); 

2、实现Runnable方式

Thread xiaoming=new Thread(new Student("小明",punishment),"小明"); xiaoming.start(); 

第一种方式中，Student继承了Thread类，启动时调用了start方法，其实用的是父类Thread的start方法，并最终触发执行Student重写的run方法。

第二种方式中，Student实现Runnable接口，作为参数传递给Thread构造函数。接下来还是调用了Thread的start方法。最后则会触发传入的Runnable实现的run方法。

两种方式都是创建Thread或者Thread的子类，通过Thread的start方法启动。唯一不同的是，第一种run方法实现在Thread子类中。第二种则是把run方法逻辑转移到Runable的实现类中。线程启动后，第一种方式是thread对象运行自己的run方法逻辑，第二种方式则是调用Runnable 实现的run方法逻辑。

实现Runnable接口比继承Thread类实现多线程更好的原因：
1、java语言中只能单继承，通过实现接口的方式，可以让实现类去继承其他类。而直接继承Thread就不能再继承其他类了。
2、线程控制逻辑在Thread类中，业务运行逻辑在Runnable实现类中。解耦更为彻底
3、实现Runnable的实例，可以被多个线程共享并执行。而实现thread是做不到这一点的。

小结

通过上文的描述，我们可以看出，Java中的多线程的实现采用了模板模式。Thread是模板对象，负责线程相关的逻辑，比如线程的创建，运行以及各种操作。而线程真正的业务则被剥离出来，交由Runnable的实现类去实现。线程操作和业务逻辑完全解耦，开发者只需要聚焦在业务逻辑上的实现即可。