1 通过继承线程类的方式
/**
* 通过继承Thread方法去实现线程
*/
public class Main1 {
public static void main(String[] args) {
new MyThread1().start();
}
}
class MyThread1 extends Thread {
public void run() {
System.out.println("我是通过继承Thread的方式重新run方法实现的");
}
}
2 通过实现 Runnable的方式实现线程
/**
* 通过实现 Runnable的方式实现线程
*/
public class Main2 {
public static void main(String[] args) {
new Thread(new MyRunnable()).start();
}
}
class MyRunnable implements Runnable {
public void run() {
System.out.println("我实现了Runnable接口,正在执行重写的方法run(),");
}
}
3 通过实现Callable自定义myCallable类作为构造参数 创建出一个 FutureTask 的方式实现
package mythread.第1集实现线程的5种方式;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
/**
* 通过实现Callable自定义myCallable类作为构造参数 创建出一个 FutureTask 的方式实现
*/
public class Main3 {
public static void main(String[] args) {
//创建一个Callable 对象
Callable<String> myCallable = new MyCallable<String>();
// 根据 Callable 创建一个 FutureTask
FutureTask<String> oneTask = new FutureTask<String>(myCallable);
// 执行线程
new Thread(oneTask).start();
}
}
class MyCallable<V> implements Callable<V> {
@Override
public V call() throws Exception {
System.out.println("我实现了Callable接口,我正在执行call()方法");
return null;
}
}
4 通过线程池的方式创建
package mythread.第1集实现线程的5种方式;
import java.util.concurrent.*;
/**
* 通过线程池的方式创建
*/
public class Main4 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
a1();
a2();
}
public static void a1() {
ExecutorService executorService = Executors.newFixedThreadPool(5);
executorService.submit(new Runnable() {
@Override
public void run() {
System.out.println("我是通过线程池的方式执行的线程方法(Runnable)(java8之前的)");
}
});
executorService.submit(() -> {
System.out.println("我是通过线程池的方式执行的线程方法(Runnable)(java8之后的)");
});
}
public static void a2() throws ExecutionException, InterruptedException {
ExecutorService executorService = Executors.newFixedThreadPool(5);
Future<String> future1 = executorService.submit(() -> {
return "我是通过线程池的方式执行的线程方法(Callable)(java8之后的)";
});
System.out.println(future1.get());
Future<String> future2 = executorService.submit(new Callable<String>() {
@Override
public String call() {
return "我是通过线程池的方式执行的线程方法(Callable)(java8之后的)";
}
});
System.out.println(future2.get());
}
}
5 通过 @Async + Future 的方式
package mythread.第1集实现线程的5种方式;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import java.util.concurrent.Future;
/**
* 注意:下面的run()方法不是异步的,因为没有配置注解和配置(如有兴趣请自己搜索 springboot @Async + Future )
*/
public class Main5 {
public static void main(String[] args) throws Exception {
FutureDemo futureDemo=new FutureDemo();
for (int i=0;i<1000;i++){
Future<String>future= futureDemo.run(i);
System.out.println(future.get());
}
}
}
class FutureDemo{
@Async("FutureExecutor")
public Future<String> run(int i) throws Exception {
return new AsyncResult<>("test:"+ i);
}
}