死磕 Java线程系列之创建线程的8种方式

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

 

简介

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

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

 

  1. public class CreatingThread01 extends Thread {  
  2.     @Override  
  3.     public void run() {  
  4.         System.out.println(getName() + " is running");  
  5.     }  
  6.     public static void main(String[] args) {  
  7.         new CreatingThread01().start();  
  8.         new CreatingThread01().start();  
  9.         new CreatingThread01().start();  
  10.         new CreatingThread01().start();  
  11.     }  

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

实现Runnable接口

 

  1. public class CreatingThread02 implements Runnable {  
  2.     @Override  
  3.     public void run() {  
  4.         System.out.println(Thread.currentThread().getName() + " is running");  
  5.     }  
  6.     public static void main(String[] args) {  
  7.         new Thread(new CreatingThread02()).start();  
  8.         new Thread(new CreatingThread02()).start();  
  9.         new Thread(new CreatingThread02()).start();  
  10.         new Thread(new CreatingThread02()).start();  
  11.     }  

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

匿名内部类

 

  1. public class CreatingThread03 {  
  2.     public static void main(String[] args) {  
  3.         // Thread匿名类,重写Thread的run()方法  
  4.         new Thread() {  
  5.             @Override  
  6.             public void run() {  
  7.                 System.out.println(getName() + " is running");  
  8.             }  
  9.         }.start();  
  10.         // Runnable匿名类,实现其run()方法  
  11.         new Thread(new Runnable() {  
  12.             @Override  
  13.             public void run() {  
  14.                 System.out.println(Thread.currentThread().getName() + " is running");  
  15.             }  
  16.         }).start();       
  17.         // 同上,使用lambda表达式函数式编程  
  18.         new Thread(()-> 
  19.             System.out.println(Thread.currentThread().getName() + " is running");  
  20.         }).start();  
  21.     }  

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

实现Callabe接口

 

  1. public class CreatingThread04 implements Callable<long> {  
  2.     @Override  
  3.     public Long call() throws Exception {  
  4.         Thread.sleep(2000);  
  5.         System.out.println(Thread.currentThread().getId() + " is running");  
  6.         return Thread.currentThread().getId();  
  7.     }  
  8.     public static void main(String[] args) throws ExecutionException, InterruptedException {  
  9.         FutureTask<long> task = new FutureTask&lt;&gt;(new CreatingThread04());  
  10.         new Thread(task).start();  
  11.         System.out.println("等待完成任务");  
  12.         Long result = task.get();  
  13.         System.out.println("任务结果:" + result);  
  14.     }  

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

定时器(java.util.Timer)

 

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

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

线程池

 

  1. public class CreatingThread06 {  
  2.     public static void main(String[] args) {  
  3.         ExecutorService threadPool = Executors.newFixedThreadPool(5);  
  4.         for (int i = 0; i &lt; 100; i++) {  
  5.             threadPool.execute(()-&gt; System.out.println(Thread.currentThread().getName() + " is running"));  
  6.         }  
  7.     }  

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

并行计算(Java8+)

 

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

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

Spring异步方法

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

 

  1. @SpringBootApplication  
  2. @EnableAsync  
  3. public class Application {  
  4.     public static void main(String[] args) {  
  5.         SpringApplication.run(Application.class, args);  
  6.     }  

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

 

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

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

 

  1. @RunWith(SpringRunner.class)  
  2. @SpringBootTest(classes = Application.class)  
  3. public class CreatingThread08Test {  
  4.     @Autowired  
  5.     private CreatingThread08Service creatingThread08Service;  
  6.     @Test  
  7.     public void test() {  
  8.         creatingThread08Service.call();  
  9.         creatingThread08Service.call();  
  10.         creatingThread08Service.call();  
  11.         creatingThread08Service.call();  
  12.     }  

运行结果如下:

 

  1. task-3 is running  
  2. task-2 is running  
  3. task-1 is running  
  4. 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接口,应该输出什么呢?

 

  1. public class CreatingThread09 {  
  2.     public static void main(String[] args) {  
  3.         new Thread(()-&gt; {  
  4.             System.out.println("Runnable: " + Thread.currentThread().getName());  
  5.         }) {  
  6.             @Override  
  7.             public void run() {  
  8.                 System.out.println("Thread: " + getName());  
  9.             }  
  10.         }.start();  
  11.     }  

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

 

  1. public class Thread implements Runnable {  
  2.     // Thread维护了一个Runnable的实例  
  3.     private Runnable target;     
  4.     public Thread() { 
  5.          init(null, null, "Thread-" + nextThreadNum(), 0);  
  6.     }    
  7.     public Thread(Runnable target) {  
  8.         init(null, target, "Thread-" + nextThreadNum(), 0);  
  9.     }    
  10.     private void init(ThreadGroup g, Runnable target, String name,  
  11.                       long stackSize, AccessControlContext acc,  
  12.                       boolean inheritThreadLocals) {  
  13.         // ...  
  14.         // 构造方法传进来的Runnable会赋值给target  
  15.         this.target = target;  
  16.         // ...  
  17.     }    
  18.     @Override  
  19.     public void run() {  
  20.         // Thread默认的run()方法,如果target不为空,会执行target的run()方法  
  21.         if (target != null) {  
  22.             target.run();  
  23.         }  
  24.     }  

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

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

 

 

责任编辑:庞桂玉 来源: 中国开源
相关推荐

2010-03-18 15:31:13

Java创建线程

2023-06-07 13:49:00

多线程编程C#

2018-04-02 14:29:18

Java多线程方式

2020-12-17 05:52:09

线程池ThreadPoolThreadPoolE

2024-11-04 09:39:08

Java​接口Thread​类

2024-02-26 08:28:24

Java线程CPU

2023-06-06 08:17:52

多线程编程Thread类

2017-04-17 19:31:03

Android多线程

2010-03-15 17:56:23

Java多线程

2023-06-08 08:21:08

多线程编程线程间通信

2022-11-02 15:00:03

Java值传递引用传递

2019-10-29 19:49:48

Java线程安全

2010-07-14 10:30:26

Perl多线程

2024-02-05 12:08:07

线程方式管理

2011-06-24 11:03:31

Qt 多线程 线程

2021-03-01 08:02:55

算法排序操作

2011-06-24 11:12:39

Qt 多线程 线程

2023-06-09 07:59:37

多线程编程锁机制

2009-03-12 10:52:43

Java线程多线程

2010-02-02 14:32:32

Python线程编程
点赞
收藏

51CTO技术栈公众号