创建线程比较传统的方式是继承Thread类和实现Runnable，也可以用内部类，Lambda表达式，线程池，FutureTask等。
经常面试会问到继承Thread类和实现Runnable的区别，然后网上会流传如下这样的说法，这是错误的。
流传很久的错误说法：
这个说法是举一个火车票售票的例子，大致意思是说实现Runnable接口可以实现多继承，这一点说的是正确的，但是错误的是下面的，那些例子会说实现Runnable接口的多线程可以实现共享，而继承Thread类的线程是不会共享的。其实之所以造成他们的说法看起来对是刻意在继承Thread类的时候故意新建几个线程，而成员变量又不是静态的自然是不能共享的。
下面就是那个流传很广的关于继承Thread类和实现Runnable的两种方式的“区别”的来源：
参考类似此文《创建线程的两种方式比较Thread VS Runnable》
说明：上面截图中的是片面的，然后很多培训机构和很多博主还引用这个，所以有必要澄清下这个问题。
正确的说法是：继承Thread类和实现Runnable的最本质的区别是继承接口可以实现多继承。继承Thread类的一样可以实现共享。
先看Thread类和Runnable接口的关系
可以看到 Runnable接口就一个run方法，然后Thread类实现了这个run方法，同时自己又实现了很多其他方法。
1.继承Thread类和重写run()方法
public class MyThread extends Thread{private String name;
private int i = 0;
public MyThread(String name){
this.name = name;
}
@Override
public void run() {
i++;
System.out.println(name+" i计数为："+i+" "+Thread.currentThread().getName());
}
}
public class MyThreadTest {public static void main(String[] args) {
MyThread mt1 = new MyThread("线程");
Thread t1 = new Thread(mt1);
Thread t2 = new Thread(mt1);
Thread t3 = new Thread(mt1);
t1.start();
t2.start();
t3.start();
}
}
说明：这样就实现了所谓继承的方式不能多个线程处理同一个资源的情况。
你可以自定义线程的name，这样就不会是Thread-0,1,2,3这样的系统生成的name了。
再修改代码：
public class MyThreadTest {public static void main(String[] args) {
MyThread t1 = new MyThread("线程1");
MyThread t2 = new MyThread("线程2");
MyThread t3 = new MyThread("线程3");
t1.start();
t2.start();
t3.start();
}
}
这次每个线程之间就不会共享数据，也就是那些谬误中的用法。
2.实现Runnable接口
public class MyThreadRunnable implements Runnable{private String name;
private int i = 0;
public MyThreadRunnable(String name){
this.name = name;
}
@Override
public void run() {
i++;
System.out.println(name+" i计数为："+i+" "+Thread.currentThread().getName());
}
}
public class MyThreadTest {public static void main(String[] args) {
//MyThread t1 = new MyThread("线程1");
//MyThread t2 = new MyThread("线程2");
//MyThread t3 = new MyThread("线程3");
MyThreadRunnable mt=new MyThreadRunnable("线程1");
Thread t1 = new Thread(mt);
Thread t2 = new Thread(mt);
Thread t3 = new Thread(mt);
t1.start();
t2.start();
t3.start();
}
}
实现Runnable接口可以共享变量。
再把代码改一改：
public class MyThreadTest {public static void main(String[] args) {
//MyThread t1 = new MyThread("线程1");
//MyThread t2 = new MyThread("线程2");
//MyThread t3 = new MyThread("线程3");
MyThreadRunnable mt1=new MyThreadRunnable("线程1");
MyThreadRunnable mt2=new MyThreadRunnable("线程2");
MyThreadRunnable mt3=new MyThreadRunnable("线程3");
Thread t1 = new Thread(mt1);
Thread t2 = new Thread(mt2);
Thread t3 = new Thread(mt3);
t1.start();
t2.start();
t3.start();
}
}
这次就不会共享变量了。
所以这样就证明了共享变量和继承Thread类和实现Runnable并无关系！
3.实现线程创建的两种简洁方式（匿名内部类+Lambda表达式）
这种方式适合于创建启动线程次数较少的环境，一般书写更加简便。
//方式1：相当于继承了Thread类，作为子类重写run()实现new Thread() {
public void run() {
System.out.println("匿名内部类创建线程方式1..." + Thread.currentThread().getName());
}
}.start();
//方式2:实现Runnable,Runnable作为匿名内部类
new Thread(new Runnable() {
public void run() {
System.out.println("匿名内部类创建线程方式2..." + Thread.currentThread().getName());
}
}).start();
//方式3:Lambda表达式创建线程
new Thread(() -> {
System.out.println("Lambda表达式创建线程方式..." + Thread.currentThread().getName());
}).start();
如果需要自定义线程名字可以修改如下：
//方式3:Lambda表达式创建线程new Thread(() -> {
System.out.println("Lambda表达式创建线程方式..." + Thread.currentThread().getName());
},"线程1").start();
4.实现线程的线程池方式
import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;
public class ThreadPool {
public static void main(String[] args) {
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(4);
for (int i = 0; i < 10; i++) {
final int index = i;
fixedThreadPool.execute(new Runnable() {
public void run() {
try {
System.out.println(index+ " "+Thread.currentThread().getName()+" "+DateUtil.getNowTimeString());
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
fixedThreadPool.shutdown();
}
}
这个帖子写的很好，还有其他几种模式： 《java常用的几种线程池比较》
newCachedThreadPool
创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool
创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。
FixedThreadPool是一个典型且优秀的线程池，它具有线程池提高程序效率和节省创建线程时所耗的开销的优点。但是，在线程池空闲时，即线程池中没有可运行任务时，它不会释放工作线程，还会占用一定的系统资源。
newSingleThreadExecutor
创建一个单线程化的Executor，即只创建唯一的工作者线程来执行任务，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。如果这个线程异常结束，会有另一个取代它，保证顺序执行。单工作线程最大的特点是可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。
newScheduleThreadPool
创建一个定长的线程池，而且支持定时的以及周期性的任务执行，支持定时及周期性任务执行。
5.实现异步的Future，FutureTask，CompletableFuture方式
本质还是线程，因为Java目前语言层面没有协程，需要三方类库或者修改JVM才可以，
参考本人另一帖：《异步编程原理以及Java实现》，具体源码分析都有本质还是调用class Executors，只不过是这种方式可以回调而已。原因是继承和实现了Runnable接口这2种方式创建线程都有一个缺陷就是：在执行完任务之后无法获取执行结果。
自从Java 1.5开始，就提供了Callable和Future，通过它们可以在任务执行完毕之后得到任务执行结果。
虽然 Future 以及相关使用方法提供了异步执行任务的能力，但是对于结果的获取却是很不方便，只能通过阻塞或者轮询的方式得到任务的结果。阻塞的方式显然和我们的异步编程的初衷相违背，轮询的方式又会耗费无谓的 CPU 资源，而且也不能及时地得到计算结果。
在Java8中，CompletableFuture提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，并且提供了函数式编程的能力，可以通过回调的方式处理计算结果，也提供了转换和组合 CompletableFuture 的方法。
6.定时器方式
这种方式不是为了实现线程，但是他确实是起了一个线程
import java.util.Timer;import java.util.TimerTask;
public class TimerTest {
public static void main(String[] args) {
Timer timer = new Timer();
timer.schedule(new
TimerTask() {
@Override
public void run() {
System.out.println("定时任务延迟0(即立刻执行),每隔1000ms执行一次"+ " "+Thread.currentThread().getName()+" "+ DateUtil.getNowTimeString());
}
}, 0, 1000);
}
}
public abstract class TimerTask implements Runnable
从类图可以看出TimerTask实现了Runnable接口的run()方法。
详细分析可以参考《Java 定时器 Timer 源码分析和使用建议》：
Timer 可以按计划执行重复的任务或者定时执行指定任务，这是因为 Timer 内部利用了一个后台线程 TimerThread 有计划地执行指定任务。
-
Timer：是一个实用工具类，该类用来调度一个线程(schedule a thread)，使它可以在将来某一时刻执行。 Java 的 Timer 类可以调度一个任务运行一次或定期循环运行。 Timer tasks should complete quickly. 即定时器中的操作要尽可能花费短的时间。
-
TimerTask：一个抽象类，它实现了 Runnable 接口。我们需要扩展该类以便创建自己的 TimerTask ，这个 TimerTask 可以被 Timer 调度。
一个 Timer 对象对应的是单个后台线程，其内部维护了一个 TaskQueue，用于顺序执行计时器任务 TimeTask 。
7.Spring异步任务支持
@EnableAsync和@Async开始异步任务支持
Spring通过任务执行器（TaskExecutor）来实现多线程和并发编程。使用ThreadPoolTaskExecutor可实现一个基于线程池的TaskExecutor.在开发中实现异步任务，我们可以在配置类中添加@EnableAsync开始对异步任务的支持，并在相应的方法中使用@Async注解来声明一个异步任务。
详细参考《@EnableAsync和@Async开始异步任务支持》
8.可以用并行流创建线程
import java.util.Arrays;import java.util.stream.Collectors;
public class StreamParallel {
public static void main(String args[]) {
for (int i = 0; i < 1000000; i++) {
Arrays.asList(1, 2, 3, 4, 5, 6, 7, 9, 8, 0, 1)
.stream()
.parallel()
.collect(Collectors.groupingBy(x -> x % 10))
.forEach((x, y) -> System.out.println(x + ":" + y));
}
}
}
可以看到默认的parallel计算启动了三个线程进行并行。
