在JAVA中，有两种方式可以实现多线程。
1、继承Thread类；
2、实现Runnable（Callable）接口。
JDK从最开始定义多线程支持时，只有两种实现要求：要么继承Thread类，要么实现Runnable接口，但是在JDK1.5开始又提供了一个新的线程接口：Callable接口。
java.long.Thread类是一个负责线程操作的类，任何类只需要继承Thread类就可以成为一个线程 的主类。但是既然是主类就必须有它的使用方法，而线程启动的主方法需要覆写Thread类中的run()方法实现，线程主体类的定义格式如下：
class 类名称 extends Thread{//继承Thread类 属性... ; //类中定义属性 方法... ; //类中定义方法 public void run(){ //覆写Thread类中的run()方法，此方法是线程的主体 线程主体方法 ; } }定义一个线程操作类：
class MyThread extends Thread{//这是一个多线程的操作类 private String name ; //定义类中的属性 public MyThread(String name ){//定义构造方法 this.name = name ; } @Override public void run(){//覆写run()方法，作为线程的主操作方法 for(int i = 0 ; i < 200 ; i ++){ System.out.println(this.name + "---->" + x) ; } } }本程序线程的主要功能是实现循环的输出操作，所有的线程与进程都是一样的，必须轮流去抢占资源，所以多线程的执行应该是多个线程彼此交替执行。也就是说，直接调用run()方法，并不能启动多线程，多线程的唯一启动方法就是Thread类中的start()方法：public void start()(调用此方法执行方法体是run()方法定义的代码)。
启动多线程：
public class Demo{ public static void main (String [] args){ MyThread mt1 = new Mythread("线程1") ;//实例化多线程类对象 MyThread mt2 = new Mythread("线程2") ; MyThread mt3 = new Mythread("线程3") ; mt1.start() ;//启动多线程 mt2.start() ; mt3.start() ; } } 疑问：为什么多线程启动不是调用run()方法而是调用start()？？为了解释多线程的启动调用的问题，可以查看java.long.Thread类的start()方法的源代码：
public synchronized void start() { if (threadStatus != 0) throw new IllegalThreadStateException(); group.add(this); boolean started = false; try { start0(); started = true; } finally { try { if (!started) { group.threadStartFailed(this); } } catch (Throwable ignore) { } } } private native void start0();可以发现在start()方法里面要调用一个start0()方法，而且此方法的结构与抽象方法类似，使用了native声明。
在JAVA的开发中有一门技术被称为JNI(Java Native Interface)技术，这门技术的特点是使用Java调用本机操作系统提供的函数。但是此技术有一个缺点，就是离不开特定的操作系统。如果想要执行线程，需要操作系统来进行资源分配，所以此操作严格来主要是由JVM负责根据不同的操作系统而实现的。即使用Thread类的start()方法不仅要启动多线程的执行代码，还要根据不同的操作系统进行资源的分配。
另外，通过上述代码可以发现，在Thread类的start()方法中会抛出一个“IllegalThreadStateException”异常，本方法里面使用了throw抛出异常，本应该用try...catch...捕获异常，或者在start()方法是使用throws声明，但是此处并没有这样做，因为此异常是继承自“RuntimeException”，这样就可以由用户选择性进行性处理，如果某一个线程兑现进行了重复启动（同一个线程对象调用多次start()方法），就会抛出此异常。
实现Runnable接口：
使用Thread类的确可以方便的进行多线程的实现，但是这种方式最大的缺点就是单继承局限性，为此，在Java中也可以利用Runnable接口来实现多线程。而这个接口的定义如下：
@FunctionalInterface interface Runnable{ public void run() ; } 在Runnable接口也定义了run()方法，所以只需要覆写run()方法即可。
使用Runnable接口实现多线程：
class MyThread extends implements Runnable{//这是一个多线程的操作类 private String name ; //定义类中的属性 public MyThread(String name ){//定义构造方法 this.name = name ; } @Override public void run(){//覆写run()方法，作为线程的主操作方法 for(int i = 0 ; i < 200 ; i ++){ System.out.println(this.name + "---->" + x) ; } } } 本程序实现了Runnable接口，也正常的覆写了run()方法，但是却会存在一个问题：要启动多线程，必须调用Thread类中的start()方法，如果继承了Thread类，那么可以直接使用Thread类中的start()方法，但是Runnable接口并没有提供可以被继承的start()方法，这是该如何启动多线程呢？
通过观察Thread类可以发现，Thread类中有一个构造方法：public Thread(Runnable target)，此方法可以接收一个Runnable接口对象。
利用Thread类启动多线程：
public class Demo{ public static void main (String [] args){ MyThread mt1 = new Mythread("线程1") ;//实例化多线程类对象 MyThread mt2 = new Mythread("线程2") ; MyThread mt3 = new Mythread("线程3") ; new Thread(mt1).start() ;//启动多线程 new Thread(mt2).start() ; new Thread(mt3).start() ; } } 本程序首先利用Thread类的对象包装了Runnable接口对象实例，然后利用了Thread类中的start()方法启动多线程。
因为在Runnable接口的声明处使用了@FunctionalInterface的注解，证明Runnable接口是一个函数式接口，那么我们就可以使用Lambda表达式的风格编写：
public class Demo{ public static void main (String [] args){ String name = "线程对象" ; new Thread(()->{ for(int x = 0 ; x < 200 ; x ++){ System.out.println(name + " - - >" + x ) ; } }).start() ; } } 本程序利用Lambda表达式直接定义的线程主体实现操作，并且依然依靠Thread类的start()方法进行启动，这样的做法比直接用Runnable接口更加方便。使用Runnable接口可以有效的避免单继承局限问题，所以在实际开发中，对于多线程的实现首选的就是Runnable接口。
面试题：请解释Thread类与Runnable接口实现多线程的区别？（请解释两种多线程实现方式的区别）
1、Thread类是Runnable接口的子类，使用Runnable接口实现多线程可以避免单继承的局限性。
2、Runnable接口实现的多线程可以比Thread类实现的多线程更好的描述数据共享这一概念！
