一、创建线程的第一种方式：
继承Thread ，由子类复写run方法。
步骤：
1，定义类继承Thread类；
2，目的是复写run方法，将要让线程运行的代码都存储到run方法中；
3，通过创建Thread类的子类对象，创建线程对象；
4，调用线程的start方法，开启线程，并执行run方法。
public class ThreadDemo extends Thread{ @Override public void run() { System.out.println("====thread====="); } public static void main(String[] args) { ThreadDemo threadTest1=new ThreadDemo(); threadTest1.start(); } }
二、创建线程的第二种方式：
实现一个接口Runnable。
步骤：
1，定义类实现Runnable接口。
2，覆盖接口中的run方法（用于封装线程要运行的代码）。
3，通过Thread类创建线程对象；
4，将实现了Runnable接口的子类对象作为实际参数传递给Thread类中的构造函数。
为什么要传递呢？因为要让线程对象明确要运行的run方法所属的对象。
5，调用Thread对象的start方法。开启线程，并运行Runnable接口子类中的run方法。
public class RunableTest{ public static void main(String[] args) { Thread thread=new Thread(new RunableDemo()); thread.run(); } } class RunableDemo implements Runnable{ @Override public void run() { System.out.println("======runnable======="); } }
三、创建线程的第三种方式：
实现一个接口Callable。
步骤：
1，定义类实现Callable接口。
2，覆盖接口中的call方法（用于封装线程要运行的代码）。
3，通过FutureTask来创建对象，用于接收运算结果；
4，将实现了Callable接口的子类对象作为实际参数传递给FutureTask类中的构造函数;
5，通过Thread类创建线程对象；
6，将FutureTask对象作为实际参数传递给Thread类中的构造函数;
7，调用Thread对象的start方法。开启线程，并运行Callable接口子类中的call方法;
8,通过Future对象的get方法获取结果。
import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; //1、创建线程式三：实现Callable接口。相较于Runnable接口的方式，方法可以有返回值，并且可以抛出异常。 //2、执行Callable方式，需要FutureTask实现类的支持，用于接收运算结果。FutureTask是Future接口的实现类 //3.FutereTask也可用于闭锁操作 public class CallableTest { public static void main(String[] args) { CallableDemo cd=new CallableDemo(); FutureTask<Integer> ft=new FutureTask(cd); new Thread(ft).start(); System.out.println("----------------"); try { Integer sum=ft.get(); System.out.println("sum===="+sum); } catch (InterruptedException|ExecutionException e) { e.printStackTrace(); } } } class CallableDemo implements Callable<Integer> { @Override public Integer call() throws Exception { int sum=0; for(int i=0;i<=100;i++){ sum+=i; } return sum; } }
原文：https://www.cnblogs.com/mabaoying/p/12317975.html