作者：唐彤

创新互联建站基于成都重庆香港及美国等地区分布式IDC机房数据中心构建的电信大带宽，联通大带宽，移动大带宽，多线BGP大带宽租用,是为众多客户提供专业雅安服务器托管报价，主机托管价格性价比高，为金融证券行业服务器托管，ai人工智能服务器托管提供bgp线路100M独享，G口带宽及机柜租用的专业成都idc公司。

简介

创建线程，是多线程编程中最基本的操作，彤哥总结了一下，大概有8种创建线程的方式，你知道吗？

1.继承Thread类并重写run()方法

public class CreatingThread01 extends Thread {
 @Override
 public void run() {
 System.out.println(getName() + " is running");
 }
 public static void main(String[] args) {
 new CreatingThread01().start();
 new CreatingThread01().start();
 new CreatingThread01().start();
 new CreatingThread01().start();
 }
}

继承Thread类并重写run()方法，这种方式的弊端是一个类只能继承一个父类，如果这个类本身已经继承了其它类，就不能使用这种方式了。

2.实现Runnable接口

public class CreatingThread02 implements Runnable {
 @Override
 public void run() {
 System.out.println(Thread.currentThread().getName() + " is running");
 }
 public static void main(String[] args) {
 new Thread(new CreatingThread02()).start();
 new Thread(new CreatingThread02()).start();
 new Thread(new CreatingThread02()).start();
 new Thread(new CreatingThread02()).start();
 }
}

实现Runnable接口，这种方式的好处是一个类可以实现多个接口，不影响其继承体系。

3.匿名内部类

public class CreatingThread03 {
 public static void main(String[] args) {
 // Thread匿名类，重写Thread的run()方法
 new Thread() {
 @Override
 public void run() {
 System.out.println(getName() + " is running");
 }
 }.start();
 // Runnable匿名类，实现其run()方法
 new Thread(new Runnable() {
 @Override
 public void run() {
 System.out.println(Thread.currentThread().getName() + " is running");
 }
 }).start();
 // 同上，使用lambda表达式函数式编程
 new Thread(()->{
 System.out.println(Thread.currentThread().getName() + " is running");
 }).start();
 }
}

使用匿名类的方式，一是重写Thread的run()方法，二是传入Runnable的匿名类，三是使用lambda方式，现在一般使用第三种（java8+），简单快捷。

4.实现Callabe接口

public class CreatingThread04 implements Callable {
 @Override
 public Long call() throws Exception {
 Thread.sleep(2000);
 System.out.println(Thread.currentThread().getId() + " is running");
 return Thread.currentThread().getId();
 }
 public static void main(String[] args) throws ExecutionException, InterruptedException {
 FutureTask task = new FutureTask<>(new CreatingThread04());
 new Thread(task).start();
 System.out.println("等待完成任务");
 Long result = task.get();
 System.out.println("任务结果：" + result);
 }
}

实现Callabe接口，可以获取线程执行的结果，FutureTask实际上实现了Runnable接口。

5.定时器（java.util.Timer）

public class CreatingThread05 {
 public static void main(String[] args) {
 Timer timer = new Timer();
 // 每隔1秒执行一次
        timer.schedule(new TimerTask() {
 @Override
 public void run() {
 System.out.println(Thread.currentThread().getName() + " is running");
 }
 }, 0 , 1000);
 }
}

使用定时器java.util.Timer可以快速地实现定时任务，TimerTask实际上实现了Runnable接口。

6.线程池

public class CreatingThread06 {
 public static void main(String[] args) {
 ExecutorService threadPool = Executors.newFixedThreadPool(5);
 for (int i = 0; i < 100; i++) {
            threadPool.execute(()-> System.out.println(Thread.currentThread().getName() + " is running"));
 }
 }
}

使用线程池的方式，可以复用线程，节约系统资源。

7.并行计算（Java8+）

public class CreatingThread07 {
 public static void main(String[] args) {
 List list = Arrays.asList(1, 2, 3, 4, 5);
 // 串行，打印结果为12345
        list.stream().forEach(System.out::print);
 System.out.println();
 // 并行，打印结果随机，比如35214
        list.parallelStream().forEach(System.out::print);
 }
}

使用并行计算的方式，可以提高程序运行的效率，多线程并行执行。

8.Spring异步方法

首先，springboot启动类加上 @EnableAsync注解（@EnableAsync是spring支持的，这里方便举例使用springboot）。

@SpringBootApplication
@EnableAsync
public class Application {
 public static void main(String[] args) {
 SpringApplication.run(Application.class, args);
 }
}

其次，方法加上 @Async注解。

@Service
public class CreatingThread08Service {
 @Async
 public void call() {
 System.out.println(Thread.currentThread().getName() + " is running");
 }
}

然后，测试用例直接跟使用一般的Service方法一模一样。

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class CreatingThread08Test {
 @Autowired
 private CreatingThread08Service creatingThread08Service;
 @Test
 public void test() {
        creatingThread08Service.call();
        creatingThread08Service.call();
        creatingThread08Service.call();
        creatingThread08Service.call();
 }
}

运行结果如下：

task-3 is running
task-2 is running
task-1 is running
task-4 is running

可以看到每次执行方法时使用的线程都不一样。

使用Spring异步方法的方式，可以说是相当地方便，适用于前后逻辑不相关联的适合用异步调用的一些方法，比如发送短信的功能。

欢迎大家关注我的公种浩【程序员追风】，文章都会在里面更新，整理的资料也会放在里面。

总结

（1）继承Thread类并重写run()方法；

（2）实现Runnable接口；

（3）匿名内部类；

（4）实现Callabe接口；

（5）定时器（java.util.Timer）；

（6）线程池；

（7）并行计算（Java8+）；

（8）Spring异步方法；

福利

上面介绍了那么多创建线程的方式，其实本质上就两种，一种是继承Thread类并重写其run()方法，一种是实现Runnable接口的run()方法，那么它们之间到底有什么联系呢？

请看下面的例子，同时继承Thread并实现Runnable接口，应该输出什么呢？

public class CreatingThread09 {
 public static void main(String[] args) {
 new Thread(()-> {
 System.out.println("Runnable: " + Thread.currentThread().getName());
 }) {
 @Override
 public void run() {
 System.out.println("Thread: " + getName());
 }
 }.start();
 }
}

说到这里，我们有必要看一下Thread类的源码：

public class Thread implements Runnable {
 // Thread维护了一个Runnable的实例
 private Runnable target;
 public Thread() {
        init(null, null, "Thread-" + nextThreadNum(), 0);
 }
 public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
 }
 private void init(ThreadGroup g, Runnable target, String name,
 long stackSize, AccessControlContext acc,
 boolean inheritThreadLocals) {
 // ...
 // 构造方法传进来的Runnable会赋值给target
 this.target = target;
 // ...
 }
 @Override
 public void run() {
 // Thread默认的run()方法，如果target不为空，会执行target的run()方法
 if (target != null) {
            target.run();
 }
 }
}

看到这里是不是豁然开朗呢？既然上面的例子同时继承Thread并实现了Runnable接口，根据源码，实际上相当于重写了Thread的run()方法，在Thread的run()方法时实际上跟target都没有关系了。

所以，上面的例子输出结果为 Thread:Thread-0，只输出重写Thread的run()方法中的内容。

最后

欢迎大家一起交流，喜欢文章记得点个赞哟，感谢支持！

文章题目：8种创建Java线程的方式，你知道几个？
分享路径：http://ybzwz.com/article/pdccgh.html