在JAVA中实现多线程有三种方式：
一、继承 Thread 类
二、实现 Runnable 接口
三、继承 Callable 类
一、继承 Thread 类
直接继承 Thread 类是最简单的多线程实现方式，你可以根据实际需求新建出多种不同的子类线程，并重写他们的 run 方式来实现不同类型的线程干不同的事情，并让他们有规划的相互合作。
优点： 直接继承就可以使用，代码简单清晰
缺点： 由于 JAVA 是单继承的，继承了 Thread 类就无法继承其他类
新建类： MainThread.java
/*** @author tom* @date 2019-11-01 09:37* @Description 通过继承 Thread 类来创建线程*/
public class MainThread extends Thread{public static void main(String[] args) {// 新建了一个 MainThread 的类实例，这个类继承了 ThreadMainThread thread1 = new MainThread();// 设置这个实例的名称（可重复）thread1.setName("tom thread");// 启动线程，此时线程开始跑 run 方法thread1.start();System.out.println("main over");// 运行 main 函数的线程叫主线程，循环打印主线程的内容// 由于主线程和其他线程存在竞争关系，故可以在打印台看到两种线程存在交互情况for (int i=0; i<50; i++) {System.out.println(Thread.currentThread().getName() + " i = " + i);}}/*** @author tom* @date 2019/11/1 9:39* @params* @return* @Description 继承了 Thread 类，必须重写 run 方法，来让这一类的线程做自己想要让他做的事情*/@Overridepublic void run() {// 循环打印出这个线程的名字for (int i=0; i<50; i++) {System.out.println(Thread.currentThread().getName() + " i = " + i);}}
}
运行类中的 main 方法，会得到：
可以看到存在 主线程 main 和 子线程 tom 的打印日志是交互显示的，证明线程之间是交互执行的，而不是同时并行执行。若同时并行执行，应是 main 一条， tom 一条。
......
tom thread i = 14
tom thread i = 15
tom thread i = 16
main i = 22
main i = 23
main i = 24
main i = 25
main i = 26
main i = 27
main i = 28
tom thread i = 17
tom thread i = 18
main i = 29
main i = 30
main i = 31
main i = 32
main i = 33
main i = 34
main i = 35
main i = 36
main i = 37
tom thread i = 19
tom thread i = 20
tom thread i = 21
main i = 38
main i = 39
tom thread i = 22
tom thread i = 23
tom thread i = 24
tom thread i = 25
tom thread i = 26
tom thread i = 27
tom thread i = 28
......二、实现 Runnable 接口
由于 JAVA 的单继承特性，继承了 Thread 的类无法再成为其他类的子类，而通过 Runnable 接口就可以解决这种情况，让我们的线程实现类可以继承其他类。
新建类： MainRunnable.java
/*** @author tom* @date 2019-11-01 09:59* @Description 使用 Runnable 接口创建子线程*/
public class MainRunnable implements Runnable {public static void main(String[] args) {// 创建 Runnable 实例MainRunnable mRu = new MainRunnable();// 创建 Thread 并传入 Runnable 实例Thread th1 = new Thread(mRu);// 设置子线程名称th1.setName("children thread");// 开启子线程th1.start();for (int i = 0; i < 50; i++) {System.out.println(Thread.currentThread().getName() + " i = " + i);}}/*** @author tom* @date 2019/11/1 10:00* @params* @return* @Description this is a function*/@Overridepublic void run() {// 打印子线程信息for (int i = 0; i < 50; i++) {System.out.println(Thread.currentThread().getName() + " i = " + i);}}
}
运行 main 方法，会得到：
......
children thread i = 30
children thread i = 31
children thread i = 32
main i = 19
main i = 20
children thread i = 33
children thread i = 34
children thread i = 35
main i = 21
main i = 22
main i = 23
main i = 24
main i = 25
main i = 26
main i = 27
main i = 28
main i = 29
main i = 30
main i = 31
main i = 32
main i = 33
main i = 34
main i = 35
children thread i = 36
children thread i = 37
children thread i = 38
children thread i = 39
children thread i = 40
children thread i = 41
main i = 36
main i = 37
main i = 38
main i = 39
main i = 40
main i = 41
children thread i = 42
children thread i = 43
children thread i = 44
children thread i = 45
children thread i = 46
children thread i = 47
children thread i = 48
children thread i = 49
main i = 42
main i = 43
main i = 44
main i = 45
......三、继承 Callable 类
继承 Callable 类可以实现线程的回调以及抛出异常，而前面两种不能。
新建类： MainCallable.java
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;/*** @author tom* @date 2019-11-01 10:08* @Description*/
public class MainCallable implements Callable<Integer> {public static void main(String[] args) {// 构建 Callable 实例类MainCallable mCall = new MainCallable();// 通过 FutureTask 类来实现回调// 需要指定回调类型，此时回调类型是 Integer，并将call实例类添加到 FutureTask 实例类中FutureTask<Integer> mFutureTask = new FutureTask<>(mCall);// 构建线程，并在构建时将 FutureTask 实例传入Thread mThread = new Thread(mFutureTask);// 设置子线程名mThread.setName("children thread");// 开启线程mThread.start();// 重要的一步，通过 FutureTask 实例的 get() 方法获取到线程返回的结果try {int count = mFutureTask.get();System.out.println("callable count = " + count);} catch (InterruptedException e) {e.printStackTrace();} catch (ExecutionException e) {e.printStackTrace();}}/*** @author tom* @date 2019/11/1 10:08* @params* @return* @Description this is a function*/@Overridepublic Integer call() throws Exception {int count = 0;for (int i=0; i<50; i++) {count++;System.out.println(Thread.currentThread().getName() + " i = " + i);}return count;}
}
运行 main 方法，会得到：
......
children thread i = 32
children thread i = 33
children thread i = 34
children thread i = 35
children thread i = 36
children thread i = 37
children thread i = 38
children thread i = 39
children thread i = 40
children thread i = 41
children thread i = 42
children thread i = 43
children thread i = 44
children thread i = 45
children thread i = 46
children thread i = 47
children thread i = 48
children thread i = 49
callable count = 50可以看到最终 main 方法里拿到的返回值是50。