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

    2021-03-17 22:36:10
    jdk8之前的实现方式,在JUC下增加了Future,从字面意思理解就是未来的意思,但使用起来却着实有点鸡肋,并不能实现真正意义上的异步,获取结果时需要阻塞线程,或者不断轮询。 @Test public void test1() throws ...

    一、创建线程

    使用Thead创建线程

    二、Future

     jdk8之前的实现方式,在JUC下增加了Future,从字面意思理解就是未来的意思,但使用起来却着实有点鸡肋,并不能实现真正意义上的异步,获取结果时需要阻塞线程,或者不断轮询。

    @Test
    public void test1() throws Exception {
    
        System.out.println("main函数开始执行");
    
        ExecutorService executor = Executors.newFixedThreadPool(1);
        Future<Integer> future = executor.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
    
                System.out.println("===task start===");
                Thread.sleep(5000);
                System.out.println("===task finish===");
                return 3;
            }
        });
        //这里需要返回值时会阻塞主线程,如果不需要返回值使用是OK的。倒也还能接收
        //Integer result=future.get();
        System.out.println("main函数执行结束");
    
        System.in.read();
    
    }

    三、CompletableFuture

    使用原生的CompletableFuture实现异步操作,加上对lambda的支持,可以说实现异步任务已经发挥到了极致。

     @Test
    public void test2() throws Exception {
        System.out.println("main函数开始执行");
        ExecutorService executor = Executors.newFixedThreadPool(2);
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(new Supplier<Integer>() {
            @Override
            public Integer get() {
                System.out.println("===task start===");
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("===task finish===");
                return 3;
            }
        }, executor);
        future.thenAccept(e -> System.out.println(e));
        System.out.println("main函数执行结束");
    }

    四、Spring的Async注解

    使用spring实现异步需要开启注解,可以使用xml方式或者java config的方式。
     (1)@Async 返回值异步

    (2)AsyncResult  有返回值

     

    展开全文
  • 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异步调用

    2018-06-25 14:00:35
    public class AsysDemo { public static void main(String[] args) throws Exception{ ExecutorService executorService = Executors.newFixedThreadPool(10); Test1 t1 = new Test1(); ...
    连接:https://www.cnblogs.com/dennyzhangdd/p/7010972.html
    public class AsyncDemo {
        public static void main(String[] args) throws Exception{
            ExecutorService executorService = Executors.newFixedThreadPool(10);
            Test1 t1 = new Test1();
            FutureTask<Integer> ft1 = new FutureTask<>(t1);
            executorService.submit(ft1);
            //会阻塞主线程
            //System.out.println("r1 = " +ft1.get());
            //jdk1.8的实现方式
            Test3 test3 = new Test3();
            CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(test3, executorService);
            //采用lambada的实现方式,不会阻塞主线程
            future1.thenAccept(e -> System.out.println(e + " ok"));
            System.out.println("main thread is running");
    
            //System.out.println("r1 = " +ft1.get());
    
            Test2 t2 = new Test2();
            FutureTask<Integer> ft2 = new FutureTask<>(t2);
            executorService.submit(ft2);
            System.out.println("r2 = " +ft2.get());
            executorService.shutdown();
        }
    }
    
    class Test1 implements Callable<Integer>{
        @Override
        public Integer call() throws Exception {
            Integer i = new Integer(1000);
            System.out.println("sleep before i = "+i);
            Thread.sleep(5000);
            i = i + 5000;
            System.out.println("sleep after i = "+i);
            return i;
        }
    }
    class Test2 implements Callable<Integer>{
        @Override
        public Integer call() throws Exception {
            Integer i = new Integer(2000);
            System.out.println("sleep before i2 = "+i);
            i = i + 5000;
            System.out.println("sleep after i2 = "+i);
            return i;
        }
    }
    
    class Test3 implements Supplier<Integer>{
        @Override
        public Integer get()  {
            Integer i = new Integer(3000);
            System.out.println("sleep before i3 = "+i);
    
            try {
                Thread.sleep(8000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            i = i + 8000;
            System.out.println("sleep after i3 = "+i);
            return i;
        }
    }
    展开全文
  • JAVA异步调用

    2013-05-22 19:36:45
    就是A调用一个系统的工作流,系统工作流做完反馈B,这是一个异步的过程。现在想做成同步的,就是A启动工作流之后停止,一直等待B被回调了,设定超时时间,如果超时A返回错误;否则返回成功。  B每次收到请求...

    就是A调用一个系统的工作流,系统工作流做完反馈B,这是一个异步的过程。现在想做成同步的,就是A启动工作流之后停止,一直等待B被回调了,设定超时时间,如果超时A返回错误;否则返回成功。


     B每次收到请求就往里面加数据
    A如果非超时处理完请求就会把数据删掉
    A这边设置一个集合
    只有集合里有工单ID了才返回结果,并且把这个ID从集合中REMOVE调
    B一来A就ADD一个 



    public class AClient2C2 {
    
    	private final long timeout = 10000;
    
    	public void test(String taskId) {
    		long count = 0;
    		while (BService2C2.getInstance().isHasTask(taskId) && count < timeout) {
    
    			try {
    				System.out.println("wait+"+count);
    				Thread.sleep(1000);
    				count += 1000;
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    		if(count>=timeout) {
    			System.out.println("超时");
    		}
    
    	}
    	
    	public static void main(String[] args){
    		
    		BService2C2.getInstance().regesitTaskId("aaaa");
    		AClient2C2 ac = new AClient2C2();
    		ac.test("aaaa");
    		BService2C2.getInstance().removeTaskId("aaaa");
    	}
    }
    




    import java.util.HashMap;
    import java.util.Map;
    
    
    public class BService2C2 {
    	
    	
    	private static BService2C2 instance;
    	
    	private static Map<String,String> map = new HashMap<String,String>();
    	
        private BService2C2() {
        	
        }
        
        public static BService2C2 getInstance(){
        	if(instance==null){
        		instance = new BService2C2();
        	}
        	return instance;
        }
        
        
        public void regesitTaskId(String taskId){
        	map.put(taskId, taskId);
        }
        
        public void removeTaskId(String taskId){
        	map.remove(taskId);
        }
        
        public boolean isHasTask(String taskId){
        	if(null!=map.get(taskId)){
        		return Boolean.TRUE;
        	}
        	return Boolean.FALSE;
        }
        
    }
    


    展开全文
  • java异步线程,java异步调用线程池中的线程,Java实现异步调用二、Futurejdk8之前的实现方式,在JUC下增加了Future,从字面意思理解就是未来的意思,但使用起来却着实有点鸡肋,并不能实现真正意义上的异步,获取结果...
  • 主要介绍了Java异步调用转同步方法实例详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Java异步调用模式

    千次阅读 2017-01-11 16:36:58
    Java异步调用模式 在长期的Java客户端开发中,最常见的一个客户端调用模式就是Java的异步调用。所谓异步调用其实就是实现一个可无需等待被调用函数的返回值而让操作继续运行的方法。在Java语言中,简单的讲就是另启...
  • 版权声明:本文为博主原创文章,未经博主允许不得转载。...AsyncTask是个人编写的一个Java异步调用框架支持用户 为什么需要AsyncTask与Asyn4J 区别 1Java传统的Thread 和 Runable功能不足 2 Asyn4J
  • java 异步调用Future知多少? 在某些时候,我们希望一个线程执行完某个任务之后,能够给我们返回某些我们想要的数据,在Future中就能实现这样的一个功能,触发哪些潜在不叫好事的操作,把调用线程给解放出来,,让...
  • 前言 先来说一下对异步和同步的理解: ...我们主要来说一下 Java 如何将异步调用转为同步。换句话说,就是需要在异步调用过程中,持续阻塞至获得调用结果。 不卖关子,先列出五种方法,然后一一举例说明...
  • java异步调用外部接口

    2020-12-24 14:42:35
    通过SpringBoot-RestTemplate方式调用 1.RestTemplate工具类 package com.singhand.companyadressredis.main.config; import org.apache.http.impl.client.CloseableHttpClient; import org.springframework....
  • A和B之间是同步调用 B和C是异步调用 现在需要A同步请求B时 B根据A的请求去异步请求C A等待 B要等到C异步返回数据之后 在将C返回的数据同步返回给A 。 有没有好的解决方案 。 感谢各位大神给我解答一下。
  • 5种必会的Java异步调用转同步的方法你会几种 转载请注明本文地址:https://www.jianshu.com/p/f00aa6f66281 源码地址:https://gitee.com/sunnymore/asyncToSync Sunny先来说一...
  • 异步调用 在网上看了半天文章,现在对异步调用的理解就是在一个进程执行的过程中,有一个执行很长时间的方法,这时候可以创建一个线程去异步调用这个方法,然后在方法执行完成之后调用回调函数告诉主进程他执行完了...
  • private List<String> getImgList(List<Img> carList) throws NoSuchAlgorithmException { List<String> list = new ArrayList();... 这里需要调用方法创建bmp图片,速度会很慢,怎么异步调用实现不影响速度
  • 通常情况下,上传(下载)多个SMB共享文件这类任务之间不存在依赖关系,可以考虑通过异步调用的方式来实现上传(下载)的并发执行,来充分利用系统资源以提高计算机的处理能力。
  • 异步与多线程的区别 一、异步和多线程有什么区别?其实,异步是目的,而多 线程是实现这个目的的方法。异步是说,A发起一个操作后(一般都是比较耗时的操作,如果不耗时的操作 就没有必要异步了),可以继续自顾自...
  • java异步调用的方法

    万次阅读 2012-09-20 09:45:48
    http://code.google.com/p/asyn4j/wiki/user_guide   1.3更新 优化代码 新增任务持久与恢复功能 任务调用和回调做为一个整体 例子: 1.调用普通方法 主方法 ... // 初始化异步工作服务
  • java异步调用理解

    2011-12-14 11:21:49
    // 防止setRealData被调用两次以上。  }  this.realdata = realdata;  this.ready = true;  notifyAll();  }  public synchronized String getContent() {  while (!ready) {  try {  wait();  } catch ...

空空如也

空空如也

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

java异步调用

java 订阅