精华内容
下载资源
问答
  • Java 实现异步调用

    万次阅读 热门讨论 2018-04-03 15:27:12
    首先 我遇到的问题是 接口调用时需要更新缓存 而更新缓存又是个说快不快的过程 所以打算做异步调用 返回我所需要的结果即可 ,至于缓存什么时候更新完 就不是我所需要关注的了废话不说 上代码public class ...

    首先 我遇到的问题是 接口调用时需要更新缓存 而更新缓存又是个说快不快的过程 所以打算做异步调用 返回我所需要的结果即可 ,至于缓存什么时候更新完 就不是我所需要关注的了

    废话不多说 上代码

    public class MyExecutor {

        private ExecutorService executor = Executors.newCachedThreadPool() ;

        public void fun() throws Exception {

            executor.submit(new Runnable(){

                @override

                    public void run() {

                        try {

                            //要执行的业务代码,我们这里没有写方法,可以让线程休息几秒进行测试

                            Thread.sleep(10000);

                            System.out.print("睡够啦~");

                        }catch(Exception e) {

                            throw new RuntimeException("报错啦!!");

                        }

                    }

            });

        }

    }

    public class Demo{

        

        public static void main(String[] args) {

            

             MyExecutor  myExecutor = new MyExecutor();

             try {

                myExecutor.fun();

                System.our.print("你先睡着,我先回家啦~");

            }catch(Exception e) {

                 throw new RuntimeException("业务程序报错啦!!");

            }

        }

    }

    好啦 代码到此结束 (ps:纯手打 若有错 请见谅) 

    运行主方法 

    会先打印(你先睡着,我先回家啦~)

    然后(睡够啦~)

    也就是说 在需要异步执行的方法未执行完毕时 主程序已经返回结果了  不需要继续等待 这样可以保证程序先返回结果 再继续执行不需要等待的繁琐的任务  当然也可以加一些方法去判断异步方法是否执行完毕。

    说一下Executors类

    这个类是用来创建线程池的

    有这么几个方法

    1、newFixedThreadPool() 创建固定大小的线程池 线程池的大小一旦达到最大值就会保持不变,如果某个线程因为执行异常而结束,那么线程池会补充一个新线程

    2、newCachedThreadPool() 创建一个可缓存的线程池,如果线程池的大小超过了处理任务所需要的线程,那么就会回收部分空闲(60s不执行任务)的线程,当任务数量增加时,此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制,线程池大小完全依赖于系统(JVM)能够创建的最大线程大小

    3、newSingleThreadExecutor() 创建一个单线程的线程池。这个线程池只有线程在工作,也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束,那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行

    4、newScheduledThreadPool() 创建一个大小无限的线程池,此线程池支持定时以及周期性执行任务的需求

    5、newSingleThreadScheduledExecutor() 创建一个单线程的线程池。此线程池支持定时以及周期性执行任务的需求


    展开全文
  • java多线程实现java后台异步调用

    千次阅读 2019-09-11 16:55:13
    例如:批量导入信息、信息过多,前台等待时间过久会发生连接超时情况可以用java多线程实现异步请求。 (此例子适用于子方法不会发生异常的情况下)。 public class Test { static boolean flage = true; ...

    java是单线程的开发语言,方法内代码未走完是不能有返回值返回出去的(影响性能)。
    例如:批量导入信息、信息过多,前台等待时间过久会发生连接超时情况可以用java多线程实现异步请求。
    (此例子适用于子方法不会发生异常的情况下)。

    
    public class Test {
    	static boolean flage = true;
    	
    	public static void main(String[] args) {
    		String s = ss();
    		System.out.println(s);	
    	}
    	
    	public static String ss (){ 
    		MyThread myThread = new Test().new MyThread();
    		myThread.start(); //开启子线程 
    		return "多线程执行成功"; 
    	}
    	public static void dd(){
    		flage = false;
    	}
    	
    	
    	public class MyThread extends Thread{
    		@Override
    		public void run() {
    			//重写多线程run 方法 即子方法
    			super.run();
    			int i = 0 ;
    			while(flage){
    				System.out.print(i+",");
    				try {
    					Thread.sleep(1000);
    				} catch (InterruptedException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    				i++;
    				if(i==5){
    					dd();
    				}
    			}
    			
    		}
    	}
    	
    }
    
    
    展开全文
  • 本文给大家分享java多线程实现异步调用的方法,感兴趣的朋友跟着脚本之家小编一起学习吧
  • Java方法异步调用,并行

    千次阅读 2019-12-27 15:58:36
    Java同一个方法在调用多个方法时默认是串行的方式,我的这个业务调用6个方法串行需要4秒左右,由于需要处理数据量比较,需要优化 原来的逻辑: //裁判文书对象转换 List<JudicialUpdateItem> ...

    Java方法异步调用,并行

    Java同一个方法在调用多个方法时默认是串行的方式,我的这个业务调用6个方法串行需要4秒左右,由于需要处理数据量比较多,需要优化
    

    原来的逻辑:

    //对象转换
    List<JudicialUpdateItem> writUpdateItems = writService.queryListByPager(businessInfoSearch);
    
    //对象转换
    List<JudicialUpdateItem> discreditUpdateItems = discreditService.queryListByPager(businessInfoSearch);
    
    //对象转换
    List<JudicialUpdateItem> penaltiesUpdateItems = penaltiesService.queryListByPager(businessInfoSearch);
    
    //对象转换
    List<JudicialUpdateItem> stockFreezeItems = stockFreezeService.queryListByPager(businessInfoSearch);
    
    //对象转换
    List<JudicialUpdateItem> abnormalItems = abnormalService.queryListByPager(businessInfoSearch);
    
    //对象转换
    List<JudicialUpdateItem> illegalItems = illegalService.queryListByPager(businessInfoSearch);
    

    优化过后大概需要1秒以内,效果明显

    CompletableFuture<List<JudicialUpdateItem>> future1 = CompletableFuture.supplyAsync(() -> writService.queryListByPager(businessInfoSearch));
    CompletableFuture<List<JudicialUpdateItem>> future2 = CompletableFuture.supplyAsync(() -> discreditService.queryListByPager(businessInfoSearch));
    CompletableFuture<List<JudicialUpdateItem>> future3 = CompletableFuture.supplyAsync(() -> penaltiesService.queryListByPager(businessInfoSearch));
    CompletableFuture<List<JudicialUpdateItem>> future4 = CompletableFuture.supplyAsync(() -> stockFreezeService.queryListByPager(businessInfoSearch));
    CompletableFuture<List<JudicialUpdateItem>> future5 = CompletableFuture.supplyAsync(() -> abnormalService.queryListByPager(businessInfoSearch));
    CompletableFuture<List<JudicialUpdateItem>> future6 = CompletableFuture.supplyAsync(() -> illegalService.queryListByPager(businessInfoSearch));
    
    try {
        //获取并行执行任务结果
        List<JudicialUpdateItem> writUpdateItems = future1.get();
        List<JudicialUpdateItem> discreditUpdateItems = future2.get();
        List<JudicialUpdateItem> penaltiesUpdateItems = future3.get();
        List<JudicialUpdateItem> stockFreezeItems = future4.get();
        List<JudicialUpdateItem> abnormalItems = future5.get();
        List<JudicialUpdateItem> illegalItems = future6.get();
        //放入结果
        resultList.addAll(writUpdateItems);
        resultList.addAll(discreditUpdateItems);
        resultList.addAll(penaltiesUpdateItems);
        resultList.addAll(stockFreezeItems);
        resultList.addAll(abnormalItems);
        resultList.addAll(illegalItems);
    }catch (Exception e){
        System.out.println("异常:"+e);
    }
    
    展开全文
  • Java多线程实现异步调用实例。运行Main可以看到结果。main是主线程,另有A,B,C三个线程用不同的时间跑完。
  • java 异步调用

    2016-02-04 11:21:19
    业务要求流程流转与数据记录(插表)异步进行使用线程实现异步调用: 1.线程配置 ...

    业务要求流程流转与数据记录(插表)异步进行

    使用线程池实现异步调用:
    1.线程池配置

    <bean id ="taskExecutor" name="esg.TaskExecutor" class ="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor" > 
            <property name = "corePoolSize" value ="5" />
            <property name = "keepAliveSeconds" value ="600" /> ---空闲线程的存活时间. 
            <property name = "maxPoolSize" value ="10" /> 
            <property name = "queueCapacity" value ="25" /> 
        </bean>`

    A.CorePool Size:設定ThreadPool可接受的主要Thread数量
    因此若ActiveThread未超過CorePool Size,則ThreadPool会继续New Thread
    B.QueueCapacity:設定當Request超過CorePool Size時,可以先暂存的数量
    因此若Request已經超過CorePool Size,則ThreadPool不會再New Thread,會先將Request放置於ArrayBlockingQueue
    若此設定不為正整数,則ThreadPool会采用沒有限制的LinkedBlockingQueue,同時會忽略MaxPool Size的設定,也就是說Thread会无限制产生下去

    C.MaxPool Size:設定當Queue满的時候,最大Thread的数量
    因此若Request超過CorePool Size,會先放入Queue中保存,若連Queue都滿了,這時候ThreadPool會再New Thread,直到等於MaxPool Size
    當Request量牴觸到MaxPool Size時,ThreadPool會將後續Request丟掉,可以實作RejectedExecutionHandler來承接這些被丟掉的Request,後續再看看是要記錄到資料庫或進行其他處置
    参阅:http://blog.csdn.net/welken/article/details/5530001
    2.

    @Resource(name = "esg.TaskExecutor")
        private TaskExecutor taskExecutor = null;
    
    
    @Transactional(rollbackFor = Exception.class)
        @Override
        public void startInstanceAsync(final Input input, final Output output) {
            taskExecutor.execute(new Runnable() {
                public void run() {
                    Logger.trace(this.getClass(), "startInstanceAsync", "开始启动后台线程,启动实例化...");
                    try {
                        //数据持久化
                    }
                    catch (RuntimeException e) {
                        Logger.trace(this.getClass(), "startInstanceAsync", "线程处理异常." + e.getLocalizedMessage());
                    }
                    Logger.trace(this.getClass(), "startInstanceAsync", "启动实例化处理完成,线程结束");
                }
            });
        }
    展开全文
  • Java多线程实现异步调用

    千次阅读 2017-03-21 16:18:59
    原文地址:Java多线程实现异步调用作者:chuansir 在JAVA平台,实现异步调用的角色有如下三个角色:调用者 提货单 真实数据 一个调用者在调用耗时操作,不能立即返回数据时,先返回一个提货单.然后在过一断时间后凭...
  • java8线程异步调用 CompletableFuture 详解
  • JAVA平台,实现异步调用的角色有如下三个角色:调用者 提货单 真实数据一个调用者在调用耗时操作,不能立即返回数据时,先返回一个提货单.然后在过一断时间后凭提货单来获取真正的数据.去蛋糕店买蛋糕,不需要等蛋糕做...
  • JAVA平台,实现异步调用的角色有如下三个角色:调用者、 提货单 、真实数据,一个调用者在调用耗时操作,不能立即返回数据时,先返回一个提货单,.然后在过一断时间后凭提货单来获取真正的数据.去蛋糕店买蛋糕,不...
  • Java实现异步调用方法(jdk1.8)

    千次阅读 2020-10-26 16:38:23
    点击上方“秋秋秋影影影”,并“星标置顶” 喜欢我的都关注我了 阅读本文大约需要 30秒 jdk1.8开始的Future 很时候,我们需要调用一个耗时方法,但是我们并不需要等待它执行完,才继续后面的...
  • 异步线程的区别 一、异步线程有什么区别?其实,异步是目的,而 线程是实现这个目的的方法。异步是说,A发起一个操作后(一般都是比较耗时的操作,如果不耗时的操作 就没有必要异步了),可以继续自顾自...
  • Java中的异步调用

    万次阅读 2015-11-29 17:00:32
    Java中的异步调用java中可以通过接口的多态特性来达到调用外部实现类的接口方法的效果,比如我们经常使用的框架,驱动程序等,都会定义许多的接口,向外部暴露统一的接口方法,内部则调用这些接口来达到业务逻辑的实现....
  • Future是Java 5添加的类,用来描述一个异步计算的结果,但是获取一个结果时方法较少,要么通过轮询isDone,确认完成后,调用get()获取值,要么调用get()设置一个超时时间。但是这个get()方法会阻塞住调用线程,这种...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,728
精华内容 691
关键字:

java多异步调用

java 订阅