JAVA多线程实现方式
1. 楔子
java有多种方式实现多线程,比如继承Thread
类或实现Runnable
接口创建无返回值的多线程、使用ExecutorService、Callable、Future
实现有返回结果的多线程等,这些该具体如何实现?各有什么不同?在什么样的场景下使用哪种方式比较好?本文就来探讨这些问题。
2.继承Thread
Thread
本质上也是实现了Runnable
接口,他是Runnable
的一个实例,本质上可以归为Runnable
。Thread
类声明如下:
public
class Thread implements Runnable {...}
Runnable
接口中只有一个run接口,代表线程要执行的操作,声明如下:
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
启动线程的唯一方法就是通过Thread类的start()方法。它将启动一个新线程,并执行run()方法。
通过自己的类直接extends Thread,并复写run()方法,就可以启动新线程并执行自己定义的run()方法。
示例代码如下:
public class ThreadForExtend extends Thread {
@Override
public void run() {
System.out.println("this thead for extends thead!");
System.out.println(Thread.currentThread().getName());
}
// 设置线程名字
public ThreadForExtend(String name) {
this.setName(name);
}
public static void main(String[] args) throws InterruptedException {
System.out.println("--step1--");
ThreadForExtend t = new ThreadForExtend("thread-threadForExtend");
t.start();
System.out.println("--step2--");
TimeUnit.SECONDS.sleep(2);
System.out.println(Thread.currentThread().getName());
System.out.println("--step3--");
}
}
结果如下:
注:这里实际上是采用了设计模式中的模板方法模式,Thread类作为模板,而run方法是在变化的,因此放到子类来实现
3. 实现Runnable接口
如果自己的类已经extends
另一个类,就无法直接extends Thread
,此时,必须通过实现Runnable接口来创建线程。
启动Runnable
实例时,需要放在Thread
中,然后调用 start()
方法.
示例代码如下:
public class ThreadForRunnable implements Runnable {
@Override
public void run() {
System.out.println("thread for runnable!");
}
public static void main(String[] args) throws InterruptedException {
System.out.println("--step1--");
Thread t = new Thread(new ThreadForRunnable());
t.start();
System.out.println("--step2--");
TimeUnit.SECONDS.sleep(2);
System.out.println("--step3--");
}
}
结果如下
main为主线程,在主线程外创建了一个另外一个线程。
如果不指定线程名字,系统会默认指定线程名,命名规则是Thread-N的形式。但是为了排查问题方便,建议在创建线程的时候指定一个合理的线程名字。
4. 使用内部类的方式
这并不是一种新的实现线程的方式,只是另外的一种写法。比如有些情况我们的线程就想执行一次,以后就用不到了
。那么像上面两种方式(继承Thread类和实现Runnable接口)都还要再定义一个类,显得比较麻烦,我们就可以通过匿名内部类
的方式来实现。使用内部类实现依然有两种,分别是继承Thread类和实现Runnable接口。代码如下:
public class ThreadForAnonymous {
public static void main(String[] args) {
// 基于接口的实现
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
printThreadInfo();
}
}
}).start();
// 基于子类的方式
new Thread() {
@Override
public void run() {
while (true) {
printThreadInfo();
}
}
}.start();
}
/**
* 输出当前线程的信息
*/
private static void printThreadInfo() {
System.out.println("当前运行的线程名为: " + Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
结果如下:
lambda 方式改造
刚才使用匿名内部类,会发现代码还是比较冗余的,lambda可以大大简化代码的编写。用lambda来改写上面的基于接口的形式的代码,如下
new Thread(() -> {
while (true) {
printThreadInfo();
}
}).start();
5.使用ExecutorService、Callable、Future实现有返回结果的多线程
我们知道,线程和数据库连接这些资源都是非常宝贵的资源。那么每次需要的时候创建,不需要的时候销毁,是非常浪费资源的。那么我们就可以使用缓存的策略,也就是使用线程池。
需要开启新线程执行有返回值的任务必须实现Callable接口。
执行Callable任务后,可以获取一个Future的对象,在该对象上调用get就可以获取到Callable任务返回的Object结果了。
结合线程池接口ExecutorService就可以实现有返回结果的多线程了。
实例如下所示:
public class ThreadForCallable {
public static void main(String[] args) throws Exception {
int poolSize = 5;
//创建固定数目线程的线程池
ExecutorService threadPoll = Executors.newFixedThreadPool(poolSize);
List<Future<Object>> futures = new ArrayList<>();
//创建多个Task
for (int i = 0; i < poolSize; i ++) {
MyTask task = new MyTask("No" + i);
//放入线程池中执行任务并取得返回值
Future<Object> future = threadPoll.submit(task);
futures.add(future);
}
//关闭线程池,但是执行的线程还需要继续执行
threadPoll.shutdown();
System.out.println("--start--");
//输出所有结果(会阻塞等待当前线程的返回结果)
for(Future<Object> f : futures) {
System.out.println(f.get(10, TimeUnit.SECONDS).toString());
}
}
private static class MyTask implements Callable<Object> {
private String taskNo;
public MyTask(String taskNo) {
this.taskNo = taskNo;
}
@Override
public Object call() throws InterruptedException {
System.out.println("任务 " + taskNo + " 启动了...");
Date startTime = new Date();
TimeUnit.SECONDS.sleep(5);
Date endTime = new Date();
long costTime = endTime.getTime() - startTime.getTime();
System.out.println("任务 " + taskNo + " 执行完毕.");
//返回值
return taskNo + " 任务返回运行结果, 任务执行耗费时间【" + costTime + "毫秒】";
}
}
}
结果如下:
说明:
-
ExecutoreService提供了
submit()
方法,传递一个Callable,或Runnable,返回Future。如果Executor后台线程池还没有完成Callable的计算,这调用返回Future对象的get()方法,会阻塞直到计算完成。 -
Future
接口 get() 方法
Future 接口提供了一个特殊的阻塞方法 get(),它返回 Callable 任务执行的实际结果,但如果是 Runnable 任务,则只会返回 null。
因为 get() 方法是阻塞的。如果调用 get() 方法时任务仍在运行,那么调用将会一直被执阻塞,直到任务正确执行完毕并且结果可用时才返回。 -
再介绍
Executors
类:
提供了一系列工厂方法用于创建线程池,返回的线程池都实现了ExecutorService
接口。public static ExecutorService newFixedThreadPool(int nThreads)
创建固定数目线程的线程池。public static ExecutorService newCachedThreadPool()
创建一个可缓存的线程池,调用execute 将重用以前构造的线程(如果线程可用)。如果现有线程没有可用的,则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。public static ExecutorService newSingleThreadExecutor()
创建一个单线程化的Executor。public static ScheduledExecutorService newScheduledThreadPool(intcorePoolSize)
创建一个支持定时及周期性的任务执行的线程池,多数情况下可用来替代Timer类。
不使用线程池的有返回值的线程创建示例代码如下:
public class ThreadForNoPool {
public static void main(String[] args) throws Exception {
// 创建线程任务
Callable<Integer> call = () -> {
System.out.println("线程任务开始执行了....");
Thread.sleep(2000);
return 1;
};
// 将任务封装为FutureTask
FutureTask<Integer> task = new FutureTask<>(call);
// 开启线程,执行线程任务
new Thread(task).start();
// ====================
// 这里是在线程启动之后,线程结果返回之前
System.out.println("这里可以为所欲为....");
// ====================
// 为所欲为完毕之后,拿到线程的执行结果
Integer result = task.get();
System.out.println("主线程中拿到异步任务执行的结果为:" + result);
}
}
6.定时器
定时器可以说是一种基于线程的一个工具类,可以定时的来执行某个任务。在应用中经常需要定期执行一些操作,比如要在凌晨的时候汇总一些数据,比如要每隔10分钟抓取一次某个网站上的数据等等,总之计时器无处不在。
在Java中实现定时任务有很多种方式,JDK提供了Timer类来帮助开发者创建定时任务,另外也有很多的第三方框架提供了对定时任务的支持,比如Spring的schedule以及著名的quartz等等。因为Spring和quartz实现都比较重,依赖其他的包,上手稍微有些难度,不在本篇博客的讨论范围之内,这里就看一下JDK所给我们提供的API来实现定时任务。
实例如下所示:
package com.sino.daily.code_2019_4_16;
import org.joda.time.DateTime;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
/**
* Created on 2019/4/17 14:32.
*
* @author caogu
*/
public class ThreadForTimer {
public static void main(String[] args) throws InterruptedException {
Timer timer = new Timer();
//指定时间点执行
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println("指定时间点执行");
}
}, DateTime.now().plusSeconds(5).toDate());
//间隔时间重复执行
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println("间隔时间重复执行");
}
}, new Date(), 2000);
Thread.sleep(10000);
// 不取消线程会一值存在
timer.cancel();
}
}
结果:
TimerTask 也是Runnable 接口的实例:
public abstract class TimerTask implements Runnable {}
6 番外:定时器改进
自JDK1.5开始,JDK提供了ScheduledThreadPoolExecutor类来支持周期性任务的调度。在这之前的实现需要依靠Timer和TimerTask或者其它第三方工具来完成。但Timer有不少的缺陷,比如:
Timer是单线程模式;
如果在执行任务期间某个TimerTask耗时较久,那么就会影响其它任务的调度;
Timer的任务调度是基于绝对时间的,对系统时间敏感;
Timer不会捕获执行TimerTask时所抛出的异常,由于Timer是单线程,所以一旦出现异常,则线程就会终止,其他任务也得不到执行
ScheduledExecutorService的主要作用就是可以将定时任务与线程池功能结合使用,来重用线程池的功能。用来替换Timer和TimerTask的实现方式。
public class ScheduledExecutorServiceTest {
public static void main(String[] args) {
//立刻执行,而且每隔1000毫秒执行一次。
ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
executorService.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("run "+ System.currentTimeMillis());
}
}, 0, 1000, TimeUnit.MILLISECONDS);
}
}
结果:
ScheduledExecutorService详细用法参考: 深入理解Java线程池:ScheduledThreadPoolExecutor
7.Spring方式:使用Spring来实现多线程
这种方式依赖于Spring3以上版本,我们可以通过Spring的@Async注解非常方便的实现多线程。具体的使用方式见 Spring Boot 对多线程支持-提高程序执行效率