一：Java创建线程方式
继承Thread类、实现Runnable接口或者实现 Executor接口
但是Runnable 的 run() 方法是不带返回值的，那如果我们需要一个耗时任务在执行完之后给予返回值，应该怎么做呢？
第一种方法：在 Runnable 的实现类中设置一个变量 V，在 run 方法中将其改变为我们期待的结果，然后通过一个 getV() 方法将这个变量返回。
package com.test.thread;
import java.util.*;
import sun.swing.AccumulativeRunnable;
//获得线程的返回结果方式一
/*
*在runnable实现类中设置一个变量x,在run方法中将其改变为我们期待的结果，然后通过一个getX()方法将这个变量返回
*/
public class RunnableTest {
public static void main(String[] args) throws Exception {
System.out.println("使用Runnable获取返回结果");
List<Thread> workers = new ArrayList<>(10);
List<RunnableAcction> tasks = new ArrayList<>(10);
//创建10个线程，每个线程分别负责累加1-10,11-20，.........，91-100
for(int i=0;i<10;i++) {
RunnableAcction task = new RunnableAcction(i*10+1,(i+1)*10);
Thread work = new Thread(task,"累加器线程"+i);
workers.add(work);
tasks.add(task);
work.start();
}
int total = 0;
for(int i = 0;i<workers.size();i++) {
workers.get(i).join();
total += tasks.get(i).getResult();
}
System.out.println("\n累加的结果："+total);
}
static final class RunnableAcction implements Runnable{
private int a;
public RunnableAcction(int a, int b) {
super();
this.a = a;
this.b = b;
}
private int b;
private int result;
@Override
public void run() {
result = 0;
try {
for(int i=a;i<= b;i++) {
result += i;
Thread.sleep(100);
}
} catch (Exception e) {
// TODO: handle exception
}
System.out.printf("(%s) - 运行结束，结果为 %d\n",Thread.currentThread().getName(),result);
}
public int getResult() {//获取线程返回结果
return result;
}
}
}
第二种方法：使用 Callable 和 FutureTask。
使用 FutureTask 的过程如下：
（1）通过一个 Callable 任务或者一个 Runnable（一开始就指定 result）任务构造 FutureTask；
（2）将 FutureTask 交给 Thread 去运行；
（3）使用 FutureTask 的 get 方法（或者 Thread 的 join 方法）阻塞当前线程直到获得任务的结果。
import java.util.*;
import java.util.concurrent.*;
public class CallableTest {
public static void main(String[] args) throws Exception {
System.out.println("使用 Callable 获得返回结果：");
List<FutureTask<Integer>> futureTasks = new ArrayList<>(10);
// 新建 10 个线程，每个线程分别负责累加 1~10, 11~20, ..., 91~100
for (int i = 0; i < 10; i++) {
AccumCallable task = new AccumCallable(i * 10 + 1, (i + 1) * 10);
FutureTask<Integer> futureTask = new FutureTask<>(task);
futureTasks.add(futureTask);
Thread worker = new Thread(futureTask, "慢速累加器线程" + i);
worker.start();
}
int total = 0;
for (FutureTask<Integer> futureTask : futureTasks) {
total += futureTask.get(); // get() 方法会阻塞直到获得结果
}
System.out.println("累加的结果: " + total);
}
static final class AccumCallable implements Callable<Integer> {
private final int begin;
private final int end;
public AccumCallable(int begin, int end) {
this.begin = begin;
this.end = end;
}
@Override
public Integer call() throws Exception {
int result = 0;
for (int i = begin; i <= end; i++) {
result += i;
Thread.sleep(100);
}
System.out.printf("(%s) - 运行结束，结果为 %d\n",
Thread.currentThread().getName(), result);
return result;
}
}
}
二：FutureTask介绍
FutureTask可用于异步获取执行结果或取消执行任务的场景。通过传入Runnable或者Callable的任务给FutureTask，直接调用其run方法或者放入线程池执行，之后可以在外部通过FutureTask的get方法异步获取执行结果。因此，FutureTask非常适合用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。另外，FutureTask还可以确保即使调用了多次run方法，它都只会执行一次Runnable或者Callable任务，或者通过cancel取消FutureTask的执行等。
一个FutureTask 可以用来包装一个 Callable 或是一个runnable对象。因为FurtureTask实现了Runnable方法，所以一个 FutureTask可以提交(submit)给一个Excutor执行(excution)。
FutureTask执行多任务计算的使用场景：
利用FutureTask和ExecutorService，可以用多线程的方式提交计算任务，主线程继续执行其他任务，当主线程需要子线程的计算结果时，再异步获取子线程的执行结果。
相当于新起一个线程去执行，不影响主线程其他代码执行，只不过获取线程结果时需要阻塞等待
import java.util.*;
import java.util.concurrent.*;
public class FutureTest1 {
public static void main(String[] args) {
Task task = new Task();// 新建异步任务,然后执行futureTask
FutureTask<Integer> future = new FutureTask<Integer>(task) {
// 异步任务执行完成，回调
@Override
protected void done() {
try {
System.out.println("future.done():" + get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
};
// 创建线程池（使用了预定义的配置）
ExecutorService executor = Executors.newCachedThreadPool();
executor.execute(future);
try {
Thread.sleep(1000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
// 可以取消异步任务
// future.cancel(true);
try {
// 阻塞，等待异步任务执行完毕-获取异步任务的返回值
System.out.println("future.get():" + future.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
// 异步任务
static class Task implements Callable<Integer> {
// 返回异步任务的执行结果
@Override
public Integer call() throws Exception {
int i = 0;
for (; i < 10; i++) {
try {
System.out.println("异步任务："+Thread.currentThread().getName() + "_" + i);
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return i;
}
}
}
package test;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
public class TestFutureTask {
public static void main(String[] args) {
class Result {
private String str;
}
ExecutorService executorService = Executors.newCachedThreadPool();
final Result result = new Result();
FutureTask<Result> futureTask = new FutureTask<Result>(new Runnable() {
public void run() {
try {
System.out.println("线程" + Thread.currentThread().getName() + "开始执行");
Thread.sleep((long) (Math.random() * 10000));
result.str = "sdsd";
System.out.println("线程" + Thread.currentThread().getName() + "执行完成");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, result);
try {
System.out.println("准备开始执行子任务 ");
executorService.execute(futureTask);
Result r1 = futureTask.get();
System.out.println("线程执行结果:" + r1.str);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
executorService.shutdown();
}
}
执行结果如下：
准备开始执行子任务
线程pool-1-thread-1开始执行
线程pool-1-thread-1执行完成
线程执行结果:sdsd
项目中使用如下：
/**
* 发HTML邮件公共方法
*/
public static void sendTextEmail(String address, String cc, String title, String content) {
BPMEmailRecord record = setRecord(address, cc, title, content);
try {
Map<String, Object> data = getConfig();
Properties ppt = (Properties) data.get("config");
String from = (String) data.get("from");
String account = (String) data.get("account");
String password = (String) data.get("password");
ExecutorService executorService= Executors.newSingleThreadExecutor();
FutureTask<Boolean> future=new FutureTask<>(()->
{
Session session = null;
if (ppt != null) {
session = Session.getDefaultInstance(ppt);
} else {
session = Session.getDefaultInstance(props);
}
MimeMessage message = new MimeMessage(session);
// 设置发件人
if (StringUtils.isNotBlank(from)) {
message.setFrom(new InternetAddress(from));
} else {
message.setFrom(new InternetAddress(FROM));
}
// 设置收件人
if (address.contains(";") || address.contains(",")) {
message.setRecipients(RecipientType.TO, getAddress(address));
} else {
message.setRecipient(RecipientType.TO, new InternetAddress(address));
}
// 抄送
if (StringUtils.isNotBlank(cc)) {
if (cc.contains(";") || cc.contains(",")) {
message.setRecipients(RecipientType.CC, getAddress(cc));
} else {
message.setRecipient(RecipientType.CC, new InternetAddress(cc));
}
}
// 设置发送时间
message.setSentDate(new Date());
// 设置邮件主题
message.setSubject(title, "UTF-8");
// 设置纯文本内容为邮件正文
message.setContent(content, "text/html;charset=UTF-8");
// 保存并生成最终的邮件内容
message.saveChanges();
// 获得Transport实例对象
Transport transport = session.getTransport();
// 打开连接
if (StringUtils.isNotBlank(account) && StringUtils.isNotBlank(password)) {
transport.connect(account, password);
} else {
transport.connect(ACCOUNT, password);
}
// 将message对象传递给transport对象，将邮件发送出去
transport.sendMessage(message, message.getAllRecipients());
// 关闭连接
transport.close();
return true;
}
);
executorService.execute(future);
try{
Boolean result = future.get(60, TimeUnit.SECONDS);
if (result && (record!=null)) {
LOG.info("BPMEmailUtils发送邮件……" + "收件：" + address + "，抄送：" + cc==null?"":("，抄送：" + cc) + "，主题：" + title + "，内容：" + content);
record.setSendTime(new Timestamp(System.currentTimeMillis()));
record.setLog("success");
saveOrUpdate(record);
} else {
LOG.error("BPMEmailUtils发送邮件……" + "创建日志失败,收件：" + address + ((cc==null)?"":("，抄送：" + cc)) + "，主题：" + title + "，内容：" + content);
}
}
catch (TimeoutException e){
record.setSendTime(new Timestamp(System.currentTimeMillis()));
record.setLog("overtime");
saveOrUpdate(record);
LOG.error("BPMEmailUtils发送邮件……" + "发送超时,收件：" + address + ((cc==null)?"":("，抄送：" + cc)) + "，主题：" + title + "，内容：" + content);
// future.cancel(true);
return;
}
} catch (Exception e) {
e.printStackTrace();
LOG.error("BPMEmailUtils发送邮件……" + "发送失败,收件：" + address + ((cc==null)?"":("，抄送：" + cc)) + "，主题：" + title + "，内容：" + content);
record.setSendTime(new Timestamp(System.currentTimeMillis()));
record.setLog(e.toString().substring(0, e.toString().length()>1000?1000:e.toString().length()));
}
}
参考文章：
https://blog.csdn.net/chenliguan/article/details/54345993
https://blog.csdn.net/linchunquan/article/details/22382487
https://segmentfault.com/a/1190000007767231
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
