创建线程，是多线程编程中最基本的操作，彤哥总结了一下，大概有8种创建线程的方式，你知道吗?
创建Java线程的方式
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()方法