首页 > 代码库 > Java多线程Future模式
Java多线程Future模式
Java多线程Future模式有些类似于Ajax的异步请求
Future模式的核心在于：去除了主函数的等待时间，并使得原本需要等待的时间段可以用于处理其他业务逻辑
假设服务器的处理某个业务，该业务可以分成AB两个过程，并且AB两个过程之间不需要彼此的返回结果 A过程需要1秒钟，B过程需要2秒钟，主线程其他操作2秒钟
按照正常编写，程序大概需要执行5秒
如果按照Future模式只需要执行2秒（取其中运行时间最久的线程的运行时间）
Future模式的核心实现在于两个方面
1.多线程运行
主线程采用多线的方式，运行几个业务无关的任务来节省主线的等待时间。
2.锁的锁定和释放
子线程执行指定的任务时，需要保证主线程能正确的获取子线程的返回数据
这里分两种情况
（1）子线程的运行时间要大于主线程处理其他业务的时间，此时主线程需要获取子线程的返回值，而子线程却还没有执行完毕，
所以在这个时候需要让主线程进入等待。子线程执行完毕以后立刻唤醒主线程。
（2）子线程的运行时间小于主线处理其他业务的时间，此时无需要等待。
知识要点：
1、wait(),notify()需要和synchronized一块使用，去掉会报 java.lang.IllegalMonitorStateException
1>当前线程不含有当前对象的锁资源的时候，调用obj.wait()方法;
2>当前线程不含有当前对象的锁资源的时候，调用obj.notify()方法。
3>当前线程不含有当前对象的锁资源的时候，调用obj.notifyAll()方法。
2、wait()方法会释放锁
Service模拟服务器处理业务的过程
package future;
import java.util.Date;
/**
* 服务器
*
* @author wpy
*
*/
public class Service {
/**
* 1.服务器的处理某个业务，该业务可以分成AB两个过程，并且AB两个过程之间不需要彼此的返回结果
* 2.A过程需要1秒钟，B过程需要2秒钟，主线程其他操作2秒钟
*
* @param args
* @throws InterruptedException
*/
public static void main(String[] args) throws InterruptedException {
Service service = new Service();
long notUseFuture = service.notUseFuture();
System.out.println("==============================");
long useFuture = service.useFuture();
System.out.println("==============================");
System.out.println("notUseFuture整个业务耗时"+notUseFuture);
System.out.println("useFuture整个业务耗时"+useFuture);
}
public long useFuture() throws InterruptedException {
Date startOn = new Date();
String name = Thread.currentThread().getName();
final FutureDate<String> futureDateA = new FutureDate<>();
final FutureDate<String> futureDateB = new FutureDate<>();
Thread a = new Thread(new Runnable() {
@Override
public void run() {
String name = Thread.currentThread().getName();
System.out.println(name + ":任务A开始执行");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
futureDateA.setData(name + ":任务A执行结果");
System.out.println(name + ":任务A执行结束");
}
}, "线程A");
Thread b = new Thread(new Runnable() {
@Override
public void run() {
String name = Thread.currentThread().getName();
System.out.println(name + ":任务B开始执行");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
futureDateB.setData(name + ":任务B执行结果");
System.out.println(name + ":任务B执行结束");
}
}, "线程B");
Date before = new Date();
a.start();
b.start();
Date after = new Date();
System.out.println(name + ":a,b阻塞主线程时间:"
+ (after.getTime() - before.getTime()));
// 假设其他业务执行两秒钟
Thread.sleep(2000);
before = new Date();
String dataA = futureDateA.getData();
after = new Date();
System.out.println(name + ":获取A线程结果时间:"
+ (after.getTime() - before.getTime()));
before = new Date();
String dataB = futureDateB.getData();
after = new Date();
System.out.println(name + ":获取线程结果时间:"
+ (after.getTime() - before.getTime()));
System.out.println(name + ":A线程结果：" + dataA);
System.out.println(name + ":B线程结果：" + dataB);
Date endOn = new Date();
/*System.out.println(name + "整个业务耗时"
+ (endOn.getTime() - startOn.getTime()));*/
return endOn.getTime() - startOn.getTime();
}
public long notUseFuture() throws InterruptedException {
Date startOn = new Date();
// 任务A
String name = Thread.currentThread().getName();
System.out.println(name + ":任务A开始执行");
Thread.sleep(1000);
System.out.println(name + ":任务A执行结束");
// 任务B
System.out.println(name + ":任务B开始执行");
Thread.sleep(3000);
System.out.println(name + ":任务B执行结束");
// 主线程其他操作
Thread.sleep(2000);
Date endOn = new Date();
return endOn.getTime() - startOn.getTime();
}
}
封装的FutrueData类
package future;
/**
* 用户获取异步任务执行结果
* @author wpy
*
*/
public class FutureDate<T> {
private boolean isReady = false;
private T data;
/**
* 异步任务执行完毕后会通过此方法将执行结果传递给data;
* @param data
*/
public synchronized void setData(T data){
if(isReady){
return;
}
this.data = http://www.mamicode.com/data;>
执行结果
main:任务A开始执行
main:任务A执行结束
main:任务B开始执行
main:任务B执行结束
==============================
main:a,b阻塞主线程时间:0
线程A:任务A开始执行
线程B:任务B开始执行
线程A:任务A执行结束
main:获取A线程结果时间:0
线程B:任务B执行结束
main:获取线程结果时间:1001
main:A线程结果：线程A:任务A执行结果
main:B线程结果：线程B:任务B执行结果
==============================
notUseFuture整个业务耗时6001
useFuture整个业务耗时3006
JDK封装的Future简单使用
package test;
import java.util.Date;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class TestFuture {
public static void main(String[] args) throws InterruptedException, ExecutionException {
Callable<Object> callable = new Callable<Object>() {
@Override
public Object call() throws Exception {
System.out.println(Thread.currentThread().getName()+":正在构造数据");
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName()+":构造数据数据完毕");
return "结果";
}
};
Date before = new Date();
FutureTask<Object> futureTask = new FutureTask<>(callable);
new Thread(futureTask).start();
Thread.sleep(1000);
Date after = new Date();
System.out.println((after.getTime() - before.getTime())/1000);
before = new Date();
System.out.println(Thread.currentThread().getName()+":主程序准备获取结果");
Object object = futureTask.get();
after = new Date();
System.out.println((after.getTime() - before.getTime())/1000);
System.out.println(object);
}
}
Java多线程Future模式
声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉： 投诉/举报 工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。