比如目前有一个简单需求是：计算两个变量的和，要求是使用多线程的方式；以下介绍三种创建线程的方式分别做实现。
1、继承Thread类
package com.test.commontest.example.thread;
/**
* @version 1.0
* @Description 线程测试类-继承Thread类(重写run方法)
*/
public class ExtendsThread {
public static void main(String[] args) throws InterruptedException {
System.out.println("主线程开始!");
Extends1Thread extendsThread = new Extends1Thread(100,100);
extendsThread.start();
//join阻塞主线程,否则下面获取result的时候，可能出现extendsThread还未执行完，导致result未赋值
extendsThread.join();
System.out.println("异步线程继承Thread类结果："+extendsThread.getResult());
System.out.println("主线程结束!");
}
/**
* 1、继承Thread类
*/
static class Extends1Thread extends Thread{
private int param;
private int param1;
private int result;
public Extends1Thread(int param,int param1) {
this.param = param;
this.param1 = param1;
}
public int getResult() {
return result;
}
@Override
public void run() {
result = param + param1;
System.out.println("线程id："+Thread.currentThread().getId()+"我是继承Thread类的方式!");
}
}
}
2、实现Runnable接口
package com.test.commontest.example.thread;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
/**
* @version 1.0
* @Description 线程测试类-实现Runnable接口(实现run方法)
*/
public class ImplementsRunnable {
static final CountDownLatch countDownLatch = new CountDownLatch(1);
public static void main(String[] args) throws InterruptedException, ExecutionException {
System.out.println("主线程开始!");
Implements1Runnable implements1Runnable = new Implements1Runnable(100,100);
Thread thread = new Thread(implements1Runnable);
thread.start();
//通过CountDownLatch的await方法进行阻塞主线程，implements1Runnable中调用countDown方法
//当CountDownLatch的计数为0的时候await就会结束阻塞执行后续逻辑
countDownLatch.await();
System.out.println("异步线程实现Runnable接口结果："+implements1Runnable.getResult());
System.out.println("主线程结束!");
}
/**
* 2、实现Runnable接口
*/
static class Implements1Runnable implements Runnable{
private int param;
private int param1;
private int result;
public Implements1Runnable(int param,int param1) {
this.param = param;
this.param1 = param1;
}
public int getResult() {
return result;
}
@Override
public void run() {
result = param + param1;
System.out.println("线程id："+Thread.currentThread().getId()+"我是实现Runnable接口的方式!");
countDownLatch.countDown();
}
}
}
3、FutureTask+实现Callable接口
package com.test.commontest.example.thread;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* @version 1.0
* @Description 线程测试类-FutureTask+实现Callable接口(实现call方法)
*/
public class ImplementsCallable {
public static void main(String[] args) throws InterruptedException, ExecutionException {
System.out.println("主线程开始!");
FutureTask futureTask = new FutureTask<>(new Implements1Callable(100, 100));
Thread thread = new Thread(futureTask);
thread.start();
//Callable配合FutureTask使用，可以通过FutureTask的get方法获取异步线程返回值并且
//get方法会阻塞主线程，直到futureTask执行完毕获取到异步线程返回值(所以不需要额外进行
//阻塞主线程等待异步线程执行完的操作)，因此这种方式不需要像前两种方式一样通过变量进行获取值
System.out.println("异步线程实现Callable接口结果："+futureTask.get());
System.out.println("主线程结束!");
}
/**
* 3、实现Callable接口
*/
static class Implements1Callable implements Callable {
private int param;
private int param1;
public Implements1Callable(int param, int param1) {
this.param = param;
this.param1 = param1;
}
@Override
public Integer call() throws Exception {
System.out.println("线程id："+Thread.currentThread().getId()+"我是实现Callable接口的方式!");
return param + param1;
}
}
}
但是项目中不可能使用以上三种方式进行多线程操作的；因为这种直接创建线程出来使用，使用完毕再销毁的方式不仅会浪费掉创建和销毁线程的时间；而且线程数量不可控，可能导致创建过多线程耗尽服务器资源。一般项目中都是使用线程池，比如spring boot整合线程池
