精华内容
下载资源
问答
  • JAVA平台,实现异步调用的角色有如下三个角色:调用者 提货单真实数据一个调用者在调用耗时操作,不能立即返回数据时,先返回一个提货单.然后在过一断时间后凭提货单来获取真正的数据.去蛋糕店买蛋糕,不需要等蛋糕做...

    在JAVA平台,实现异步调用的角色有如下三个角色:调用者 提货单真实数据一个调用者在调用耗时操作,不能立即返回数据时,先返回一个提货单.然后在过一断时间后凭提货单来获取真正的数据.去蛋糕店买蛋糕,不需要等蛋糕做出来(假设现做要很长时间),只需要领个提货单就可以了(去干别的事情),等到蛋糕做好了,再拿提货单取蛋糕就可以了。public class Main { public static void main(String[] args) {

    System.out.println("main BEGIN");

    Host host = new Host();

    Data data1 = host.request(10, 'A');

    Data data2 = host.request(20, 'B');

    Data data3 = host.request(30, 'C');

    System.out.println("main otherJob BEGIN");

    try {

    Thread.sleep(200);

    } catch (InterruptedException e) {

    }

    System.out.println("main otherJob END");

    System.out.println("data1 = " + data1.getContent());

    System.out.println("data2 = " + data2.getContent());

    System.out.println("data3 = " + data3.getContent());

    System.out.println("main END");

    }

    }

    这里的main类就相当于“顾客”,host就相当于“蛋糕店”,顾客向“蛋糕店”定蛋糕就相当于“发请求request”,返回的数据 data是FutureData的实例,就相当于提货单,而不是真正的“蛋糕”。在过一段时间后(sleep一段时间后),调用 data1.getContent(),也就是拿提货单获取执行结果。

    下面来看一下,顾客定蛋糕后,蛋糕店做了什么:

    public class Host {

    public Data request(final int count, final char c) {

    System.out.println("request(" + count + ", " + c + ") BEGIN");

    // (1) 建立FutureData的实体

    final FutureData future = new FutureData();

    // (2) 为了建立RealData的实体,启动新的线程

    new Thread() {

    public void run() {

    //在匿名内部类中使用count、future、c。

    RealData realdata = new RealData(count, c);

    future.setRealData(realdata);

    }

    }.start();

    System.out.println("request(" + count + ", " + c + ") END");

    展开全文
  • 首先 我遇到的问题是 接口调用时需要更新缓存 而更新缓存又是个说快不快的过程 所以打算做异步调用 返回我所需要的结果即可 ,至于缓存什么时候更新完 就不是我所需要关注的了废话不多说 上代码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() 创建一个单线程的线程池。此线程池支持定时以及周期性执行任务的需求

    ---------------------

    作者:LittleYoungMan

    来源:CSDN

    原文:https://blog.csdn.net/java_ying/article/details/79803470

    版权声明:本文为博主原创文章,转载请附上博文链接!

    展开全文
  • java利用多线程实现异步调用package com.test.t1;public class Test2 {public static void main(String[] args) {final FutureTicket ft = new FutureTicket(new MyProcessData());// 在新线程中调用耗时操作new ...

    java利用多线程实现异步调用

    package com.test.t1;

    public class Test2 {

    public static void main(String[] args) {

    final FutureTicket ft = new FutureTicket(new MyProcessData());

    // 在新线程中调用耗时操作

    new Thread() {

    public void run() {

    ft.makeRealData();

    }

    }.start();

    ft.putData();

    }

    }

    class FutureTicket {

    private Object data = null;

    private boolean completed = false;

    private ProcessData pd;

    public FutureTicket(ProcessData pd) {

    this.pd = pd;

    }

    public synchronized void makeRealData() {

    if (this.completed)

    return;

    // 获取数据的耗时操作.这里用Sleep代替

    try {

    Thread.sleep(10000);

    } catch (Throwable t) {

    }

    this.data = "返回的数据内容";

    this.completed = true;

    notifyAll();

    }

    public synchronized void putData() {

    while (!this.completed) {

    try {

    wait();

    } catch (Throwable t) {

    }

    }

    // return this.data;

    // 不用返回了,直接处理

    this.pd.process(this.data);

    // alert(?);

    }

    // 这个方法也可以不要了.

    public boolean isCompleted() {

    return this.completed;

    }

    }

    interface ProcessData {

    public void process(Object data);

    }

    class MyProcessData implements ProcessData {

    public void process(Object data) {

    // 你不管什么时候起初数据data被获取了.

    // 你只要规定如果获取到数据了如何处理

    System.out.println(data.toString() + "处理完成...........");

    // insert into dataBase?

    }

    }

    展开全文
  • 本文给大家分享java线程实现异步调用的方法,感兴趣的朋友跟着脚本之家小编一起学习吧
  • 在多线程交互的中2,经常有一个线程需要得到另个一线程的计算结果,我们常用的是Future异步模式来加以解决。 Future顾名思意,有点像期货市场的“期权”,是“对未来的一种凭证”,例如当我们买了某个房地产开发商...

    在多线程交互的中2,经常有一个线程需要得到另个一线程的计算结果,我们常用的是Future异步模式来加以解决。
    Future顾名思意,有点像期货市场的“期权”,是“对未来的一种凭证”,例如当我们买了某个房地产开发商的期房,交钱之后,开发商会给我们一个凭证 (期权),这个凭证告诉我们等明年某个时候拿这个凭证就可以拿到我们所需要的房子,但是现在房子还没建好。市场上之所以有“期货”,也正由于有这种需求, 才有这种供给。

     

    这种应用在GUI上用的比较多,在设计模式中一般称为“虚拟代理模式”。

     

    例如:现在有个这样的需求,Client向Server提交一个Request(int count,char c),希望获取一个由count个字符c构造出来的字符串。比如发送Request(10,'K'),那么反馈字符串“KKKKKKKKKK”,但是我们 假设这个生成字符串的过程很费时间。

     

    于是,为了获取比较好的交互性,我们的Server收到请求后,先构造一个FutureData,并把这个所谓的“期权(未来凭证)”反馈给 Client;于此同时,通过另一个并发线程去构造一个真正的字符串RealData,并在构造完毕后,RealData给FutureData报告一个 消息,说数据(期房)已经准备好了,此时Client可以通过期权拿到期房,但是假如我们的Client比较着急,还没等房子假好的时,就想要房子,怎么 办呢?这个时候我们可以阻塞Client所在的线程,让Client等待,直到最后RealData通知FutureData说房子好了,才返回。

    这里的要点:

    (1)Server先给Client一个“期权”,同时开一个线程去干活建房子(未来的“现房”);

    (2)当“现房”RealData准备好了的时候,如何告诉FutureData说已经准备好了。(本处采用“回调过程”(借用观察者模式,来实现回调))

    (3)如果客户比较着急,现房还没准备好的时候,就要取房,怎么办?  本处采用“阻塞”。

     

    Data(公共数据接口)

     

    Java代码  收藏代码
    1. package  com.umpay.future;  
    2.   
    3. public   interface  Data {  
    4.     public   abstract  String getContent();  
    5. }  

     

    FutureData(期权)

     

    Java代码  收藏代码
    1. package  com.umpay.future.extend;  
    2.   
    3. import  java.util.Observable;  
    4. import  java.util.Observer;  
    5.   
    6. import  com.umpay.future.Data;  
    7.   
    8. public   class  FutureData2  implements  Data,Observer {  
    9.   
    10.     /**   
    11.      * 存放真实数据,并且标志真正的数据是否已经准备完毕  
    12.      * 被多线程享受  
    13.      * 如果realData2==null,表示数据还准备好  
    14.      * */   
    15.     private   volatile  RealData2 realData2 =  null ;  
    16.     /**  
    17.      * 查看真正的数据是否准备完毕  
    18.      * */   
    19.     public   boolean  isFinished() {  
    20.         return  realData2 !=  null ;  
    21.     }  
    22.       
    23.     /**  
    24.      * 如果数据已经准备好,则返回真正的数据;  
    25.      * 否则,阻塞调用线程,直到数据准备完毕后,才返回真实数据;  
    26.      * */   
    27.     public  String getContent() {  
    28.         synchronized  (mutex) {  
    29.             while (!isFinished()) { //只要数据没有准备完毕,就阻塞调用线程   
    30.                 try  {  
    31.                     mutex.wait();  
    32.                 } catch  (InterruptedException e) {  
    33.                     e.printStackTrace();  
    34.                 }  
    35.             }  
    36.             return  realData2.getContent();  
    37.         }  
    38.     }  
    39.   
    40.     /**  
    41.      *  当 RealData2 准备完数据后,RealData2 应该通知 FutureData2 数据准备完毕。  
    42.      *  并在输入参数 realData 传入真实数据,在参数 event 传入事件(比如数据如期准备好了,或出了什么异常)  
    43.      *  
    44.      *  @param  realData    真实的数据  
    45.      *  @param  event       事件类型  
    46.      * */   
    47.     public   void  update(Observable realData, Object event) {  
    48.         System.out.println("通知...." +event);  
    49.         if (!(realData  instanceof  RealData2)) {  
    50.             throw   new  IllegalArgumentException( "主题的数据类型必须是RealData2" );  
    51.         }  
    52.         if (!(event  instanceof  String)) {  
    53.             throw   new  IllegalArgumentException( "事件的数据类型必须是String" );  
    54.         }  
    55.         synchronized  (mutex) {  
    56.             if (isFinished()) {  
    57.                 mutex.notifyAll();  
    58.                 return ; //如果数据已经准备好了,直接返回.   
    59.             }  
    60.             if ( "Finished" .equals(event)) {  
    61.                 realData2 = (RealData2)realData;//数据准备好了的时候,便可以通知数据准备好了   
    62.                 mutex.notifyAll();//唤醒被阻塞的线程   
    63.             }   
    64.         }  
    65.     }  
    66.   
    67.     private  Object mutex =  new  Object();  
    68. }  

     

    RealData(实际数据)

     

    Java代码  收藏代码
    1. package  com.umpay.future.extend;  
    2.   
    3. import  java.util.Observable;  
    4.   
    5. import  com.umpay.future.Data;  
    6.   
    7. public   class  RealData2  extends  Observable  implements  Data {  
    8.   
    9.     private  String content;  
    10.   
    11.     public  RealData2() {  
    12.           
    13.     }  
    14.       
    15.     public   void  createRealData2( int  count,  char  c) {  
    16.         System.out.println("        making RealData("  + count +  ", "  + c  
    17.                 + ") BEGIN" );  
    18.         char [] buffer =  new   char [count];  
    19.         for  ( int  i =  0 ; i < count; i++) {  
    20.             buffer[i] = c;  
    21.             try  {  
    22.                 Thread.sleep(100 );  
    23.             } catch  (InterruptedException e) {  
    24.             }  
    25.         }  
    26.         System.out.println("        making RealData("  + count +  ", "  + c  
    27.                 + ") END" );  
    28.         this .content =  new  String(buffer);  
    29.           
    30.         //真实数据准备完毕了,通知FutureData2说数据已经准备好了.   
    31.         setChanged();//必须先设置本对象的状态发生了变化,并且通知所有的观察者   
    32.         notifyObservers("Finished" );  
    33.     }  
    34.       
    35.   
    36.     public  String getContent() {  
    37.         return  content;  
    38.     }  
    39. }  

     

     

    服务端代码:

     

    Java代码  收藏代码
    1. package  com.umpay.future.extend;  
    2.   
    3. import  com.umpay.future.Data;  
    4.   
    5. public   class  HostServer2 {  
    6.   
    7.     public  Data request( final   int  count,  final   char  c) {  
    8.         System.out.println("    request("  + count +  ", "  + c +  ") BEGIN" );  
    9.   
    10.         // (1) 建立FutureData的实体   
    11.         final  FutureData2 future2 =  new  FutureData2();  
    12.   
    13.         // (2) 为了建立RealData的实体,启动新的线程   
    14.         new  Thread() {  
    15.             public   void  run() {  
    16.                 RealData2 realdata2 = new  RealData2();  
    17.                 realdata2.addObserver(future2);//以便当RealData2把数据准备完毕后,通过该回调口子,通知FutureData2表示数据已经贮备好了   
    18.                 realdata2.createRealData2(count, c);  
    19.             }  
    20.         }.start();  
    21.   
    22.         System.out.println("    request("  + count +  ", "  + c +  ") END" );  
    23.   
    24.         // (3) 取回FutureData实体,作为传回值   
    25.         return  future2;  
    26.     }  
    27.   
    28. }  

     

    客户端代码:

     

    Java代码  收藏代码
    1. package  com.umpay.future;  
    2.   
    3. import  com.umpay.future.extend.HostServer2;  
    4.   
    5. public   class  MainClient {  
    6.     public   static   void  main(String[] args) {  
    7. //      testHostServer();   
    8.         testHostServer2();  
    9.     }  
    10.       
    11.     static   void  testHostServer() {  
    12.         System.out.println("main BEGIN" );  
    13.         HostServer hostServer = new  HostServer();  
    14.         Data data1 = hostServer.request(10 'A' );  
    15.         Data data2 = hostServer.request(20 'B' );  
    16.         Data data3 = hostServer.request(30 'C' );  
    17.   
    18.         System.out.println("main otherJob BEGIN" );  
    19. //        try {   
    20. //            Thread.sleep(2000);   
    21. //        } catch (InterruptedException e) {   
    22. //        }   
    23.         System.out.println("main otherJob END" );  
    24.   
    25.         System.out.println("data1 = "  + data1.getContent());  
    26.         System.out.println("data2 = "  + data2.getContent());  
    27.         System.out.println("data3 = "  + data3.getContent());  
    28.         System.out.println("main END" );  
    29.   
    30.     }  
    31.   
    32.     static   void  testHostServer2() {  
    33.         System.out.println("main BEGIN" );  
    34.         HostServer2 hostServer2 = new  HostServer2();  
    35.         Data data1 = hostServer2.request(10 'A' );  
    36.         Data data2 = hostServer2.request(20 'B' );  
    37.         Data data3 = hostServer2.request(30 'C' );  
    38.   
    39.         System.out.println("main otherJob BEGIN" );  
    40. //        try {   
    41. //            Thread.sleep(2000);   
    42. //        } catch (InterruptedException e) {   
    43. //        }   
    44.         System.out.println("main otherJob END" );  
    45.   
    46.         System.out.println("data1 = "  + data1.getContent());  
    47.         System.out.println("data2 = "  + data2.getContent());  
    48.         System.out.println("data3 = "  + data3.getContent());  
    49.         System.out.println("main END" );  
    50.   
    51.     }  
    52. }  

     

    展开全文
  • java利用多线程实现异步调用package com.test.t1;public class Test2 {public static void main(String[] args) {final FutureTicket ft = new FutureTicket(new MyProcessData());// 在新线程中调用耗时操作new ...
  • JAVA平台,实现异步调用的角色有如下三个角色:调用者 提货单 真实数据一个调用者在调用耗时操作,不能立即返回数据时,先返回一个提货单.然后在过一断时间后凭提货单来获取真正的数据.去蛋糕店买蛋糕,不需要等蛋糕做...
  • Java平台,实现异步调用的角色有如下三个角色:调用者、 提货单 、真实数据,一个调用者在调用耗时操作,不能立即返回数据时,先返回一个提货单.然后在过一断时间后凭提货单来获取真正的数据.去蛋糕店买蛋糕,不需要...
  • Java线程实现异步调用实例。运行Main可以看到结果。main是主线程,另有A,B,C三个线程用不同的时间跑完。
  • 一个调用者在调用耗时操作,不能立即返回数据时,先返回一个提货单.然后在过一断时间后凭提货单来获取真正的数据.去蛋糕店买蛋糕,不需要等蛋糕做出来(假设现做要很长时间),只需要领个提货单就可以了(去干别的事情),...
  • java线程异步调用

    千次阅读 2018-11-07 09:54:13
    本文主要讲解生产环境中遇到的异步加载数据问题以及相应的解决思路。 系统登录的时候,需要根据用户ID生成一些和当前...在Java程序中,如果想实现异步调用方法的功能,需要通过线程方式实现,即实现java.lang.Ru...
  • Java线程实现异步调用

    千次阅读 2017-03-21 16:18:59
    原文地址:Java线程实现异步调用作者:chuansir 在JAVA平台,实现异步调用的角色有如下三个角色:调用者 提货单 真实数据 一个调用者在调用耗时操作,不能立即返回数据时,先返回一个提货单.然后在过一断时间后凭...
  • JAVA平台,实现异步调用的角色有如下三个角色:调用者、 提货单 、真实数据,一个调用者在调用耗时操作,不能立即返回数据时,先返回一个提货单,.然后在过一断时间后凭提货单来获取真正的数据.去蛋糕店买蛋糕,不...
  • 一、创建线程@Testpublic void test0() throws Exception {System.out.println("main函数开始执行");Thread thread=new Thread(new Runnable() {@Overridepublic void run() {System.out.println("===task start===...
  • java 线程异步调用

    2013-12-21 21:23:24
    1、继承implements Runnable 如: public class PurchaseSerialNewController extends ...2、实现run 方法 /** * 创建一个线程,用于框架协议的启用、禁用 */ public void run() { ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 873
精华内容 349
关键字:

java实现线程异步调用

java 订阅