本文主要介绍了Java异步实现的几种方式的总结,具有很好的参考价值,希望对大家有所帮助。如有错误或不足之处,请不吝赐教。
Java 异步实现的几种方式
1. jdk1.8之前的Future
jdk的平行契约中的未来代表了一个未来的结果。当我们向线程池提交一个任务时,我们会返回这个对象,我们可以通过未来得到执行结果。但是jdk1.8之前的未来有点鸡肋,无法实现真正的异步。它需要阻塞来获得结果,或者持续轮询。
通常,我们希望线程在完成一些耗时的任务时,能够自动通知我们结果。可惜原生jdk1.8之前不支持这个,不过我们可以通过第三方库实现真正的异步回调。
/**
* JDK 1.8之前的未来
* @作者管理员
*/
公共类JavaFuture {
公共静态void main(String[] args)引发Throwable,ExecutionException {
ExecutorService executor=executors . newfixedthreadpool(1);
future string f=executor . submit(new callable string(){
@覆盖
公共字符串调用()引发异常{
System.out.println('任务已启动!');
long time method();
System.out.println('任务完成!');
回‘你好’;
}
});
//这里get()方法阻塞了主线程
system . out . println(f . get());
System.out.println(“主线程被阻塞”);
}
}
如果想得到耗时操作的结果,可以通过get()方法得到,但是这个方法会阻塞当前线程。当我们完成一些剩余的工作时,我们可以调用get()方法来尝试获得结果。
还可以调用非阻塞方法isDone来确定操作是否完成,这与下面的过程有些类似:
2. jdk1.8开始的Future
直到jdk1.8才真正支持异步操作,jdk1.8中提供了lambda表达式,让java离函数式语言更近了一步。借助jdk的native CompletableFuture可以实现异步操作,结合lambada表达式可以大大简化代码量。代码示例如下:
包netty _ promise
导入Java . util . concurrent . completablefuture;
import Java . util . concurrent . execution exception;
导入Java . util . concurrent . executorservice;
导入Java . util . concurrent . executors;
导入Java . util . function . supplier;
/**
*基于jdk1.8的任务异步处理
* @作者管理员
*/
公共类JavaPromise {
公共静态void main(String[] args)引发Throwable,ExecutionException {
//两个线程的线程池
ExecutorService executor=executors . newfixedthreadpool(2);
//jdk1.8之前的实现
CompletableFutureString future=completablefuture . supplyasync(new SupplierString(){
@覆盖
公共字符串get() {
System.out.println('任务已启动!');
尝试{
//模拟耗时的操作
long time method();
} catch (InterruptedException e) {
e . printstacktrace();
}
返回“任务完成!”;
}
},执行人);
//采用lambada的实现方式
future . then accept(e-system . out . println(e ' ok '));
System.out.println('主线程正在运行');
}
}
实现类似于下图:
3. Spring的异步方法
先把longTimeMethod封装到Spring的异步方法中,这个异步方法的返回值是Future的一个实例。这个方法必须写在Spring管理的类中。注意@Async。
@服务
公共类异步服务{
@Async
public Future springAsynchronousMethod(){
整数result=long time method();
返回新的AsyncResult(结果);
}
}
其他类调用此方法。这里很重要的一点是,其他类如果在同一个类中调用,是不会生效的。
@自动连线
私有异步服务异步服务;
public void useAsynchronousMethod(){
future future=asynchronous service . spring asynchronous method();
future.get(1000,时间单位。毫秒);
}
实际上,Spring只在原生的Future中封装了一次,我们最终得到的是Future实例。
4. Java如何将异步调用转为同步
换句话说,需要阻塞异步调用,直到获得调用结果。
使用等待和通知方法。
使用条件锁
将来的
使用CountDownLatch
使用循环屏障
五种方法,具体例子见这篇文章。
java异步任务处理
1、场景
最近在做项目的时候遇到了一个小问题:从前台提交到服务器A,服务器B被A调用处理超时。原因是前端曾经请求向db中插入10000个数据,插入后会清空缓存并发送消息。
服务器端有三个操作:A、插入DB b、清理缓存c、发送消息。一万条数据,多说,少说。而且,不仅仅是插入。出现超时现象不奇怪~ ~
2、分析
如何避免超时?一个请求可以处理太多的数据,这些数据可以分成多个请求。每个请求可以处理100条数据,可以有效解决超时问题。为了不影响用户体验,请求改为ajax异步请求。
另外,仔细分析场景。操作A是这个处理的核心,而操作B和C可以异步处理。换句话说,操作A可以在处理后立即返回结果,不需要等B和C处理完再返回。b和C操作可以在异步任务中处理。
3、实战
(1)执行者服务:任务提交
(2)、演示
异步任务类
公共类执行器演示{
private ExecutorService executor=executors . newfixedthreadpool(1);
public void asynTask()引发InterruptedException {
executor.submit(new Runnable() {
@覆盖
公共无效运行(){
尝试{
thread . sleep(10000);//方便观察结果
} catch (InterruptedException e) {
e . printstacktrace();
}
int sum=0;
for(int I=0;i 1000i ) {
sum=I;
}
system . out . println(sum);
}
});
}
}
客户端模拟
公共类客户端{
公共静态void main(String[] args)引发InterruptedException {
布尔型r=task 2();
如果(r) {
task 3();
}
system . out . println('-main end-');
}
静态布尔task2()引发InterruptedException {
executor demo e=new executor demo();
e . asyntask();
system . out . println('-task 2 end-');
返回true
}
静态void task3()引发InterruptedException {
int j=0;
while(true) {
如果(j 10000) {
打破;
}
}
system . out . println('-task 3 end-');
}
}
原来是酱紫。
-任务2结束-
-任务3结束-
-主端-
499500
我们来分析一下结果。task2是一个异步任务。当它执行到task2时,主线程不会在task2处被阻塞,所以可以执行task3,而不用等待task2完成处理。
郑重声明:本文由网友发布,不代表盛行IT的观点,版权归原作者所有,仅为传播更多信息之目的,如有侵权请联系,我们将第一时间修改或删除,多谢。