• java实现异步调用实例


    在JAVA平台,实现异步调用的角色有如下三个角色:
     
    调用者 取货凭证   真实数据
     
    一个调用者在调用耗时操作,不能立即返回数据时,先返回一个取货凭证.然后在过一断时间后
    凭取货凭证来获取真正的数据.
     
    所以连结调用者和真实数据之间的桥梁是取货凭证.我们先来看它的实现:
     
    public class FutureTicket{
     private Object data = null;
     private boolean completed = false;
     
     public synchronized void makeRealData(){
      if(this.complited) return;
      //获取数据的耗时操作.这里用Sleep代替
      try{
       Thread.sleep(10000);
      }catch(Throwable t){}
      this.data = "返回的数据内容";
      this.completed = true;
      notifyAll();
     }
     
     public synchronized Object getData(){
      while(!this.completed)){
       try{
        wait();
       }catch(Throwable t){}
      }
      return this.data;
      
     }
     public boolean isCompleted(){
      return this.completed;
     }
    }
     
    为了简单化说明(不把它们的关系开得复杂),这里用Objectb代替了真实数据.而真实的实现中
    我们应该把makeData放在一个真实数据的类中,然后提供一个方法返回真实数据.这样对于真实
    数据的处理和取货凭证解耦.
     
    对于这个取货凭证,调用者的如何调用是异步调用的关键:
     
    publc class Requester{
     public FutureTicket request(){
      final FutureTicket ft = new FutureTicket();
      
      //在新线程中调用耗时操作
      new Thread(){
       public void run(){
        ft.makeRealData();
       }
      }.start();
      return ft;
     }
    }
    在新线程中启动耗时操作后,不等待线程的完成立即返回提货单.
     
    然后调用者可以根据ft.isCompleted()来调用getData()获取真实数据.
    当然对ft.isCompleted()测试可以按规定时间间隔轮巡(极低级的方案),也可以
    在条件不满足时wait(),然后等待makeData的notifyAll();这样你就完成了一个
    用JAVA模拟的异步操作.
     

    改进:
    但这样的调用对于调用者来说仍然要继续控制线程操作.如果调用者是一个资深的
    程序员,这当然没有问题.但假如我们把对直接数据的处理委托给取货凭证来做.调用
    者直接规定对数据的操作,然后由取货凭证来调用规定的操作,这对于调用者是一个很
    好的解脱:
     
    interface ProcessData{
     public void process(Onject data);
    }
     
    public MyProcessData{
     public void process(Object data){
      //你不管什么时候起初数据data被获取了.
      //你只要规定如果获取到数据了如何处理
      
      System.out.println(data.toString() + "处理完成...........");
      //insert into dataBase?
     }
    }
     
    取货凭证在接收调用者请求获取数据时,要知道对获取的数据如何处理的方法:
     
    public class FutureTicket{
     private Object data = null;
     private boolean completed = false;
     private ProcessData pd;
     
     public FutureTicket(ProcessData pd){
      this.pd = pd;
     }
     public synchronized void makeRealData(ProcessData pd){
      if(this.complited) 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;
     }
    }
     
    调用:
     
      final FutureTicket ft = new FutureTicket(new ProcessData());
      
      //在新线程中调用耗时操作
      new Thread(){
       public void run(){
        ft.makeRealData();
       }
      }.start();
      ft.putData();

    }

    在实际编程中,往往需要网络的异步处理。比如客户程序,如果客户程序运行先于服务程序,则客户程序则需要在服务程序启动后再自动连接服务程序;在客户程序运行中如果服务程序中途停止,则也需要在不停止的条件下,等待服务程序运行并重新连接。下面提供了一类异步编程的方法。

      网络异步应用涉及到如下几个关键点:

      客户应用启动后,检测服务应用是否存在。如果不存在,则等待服务应用启动,同时不堵塞客户应用其他任务的执行。一旦服务应用启动,客户应用应该及时的与其建立连接。

      客户应用和服务应用在数据通信中,服务应用异常退出后,客户应用应可以检测到服务应用的退出。同时客户应用自动清除该通信链路,回到初始状态,等待服务应用重新启动。

      该网络异步编程首先涉及到一个定时器和定时器事件。该定时器用于不断的检测网络中客户应用和服务应用是否连通,同时在服务应用出现异常时中止数据通信,返回到初始状态。网络的故障可以通过网络方法的异常处理获知。

      定时器包含在网络通信类中,使得使用该类的应用感知不到定时器的存在,而方便的处理网络信息。

      该客户程序类如下结构:

        public class NetComm 
      implements ActionListener 
      { 
          javax.swing.Timer timer = new javax.swing.Timer(3000,this); 
          Socket sock; 
          private EventNotifier en; 
          public static int net_state = 0; 
          InetAddress ServerAddr; 
          int ServerPort; 
          public NetComm(InetAddress addr, int port){ 
          ServerAddr = addr; 
          ServerPort = port; 
      } 
      public void NetComm_Init() { 
          net_state = 1; 
          try { 
              sock = new Socket(ServerAddr, ServerPort); 
          } catch (IOException e) { 
              net_state = 0; 
          } 
          timer.start(); 
      } 
      public void NetComm_Data() 
      { 
          try { 
              OutputStream outputstream = sock.getOutputStream(); 
              BufferedWriter out = new BufferedWriter 
              (new OutputStreamWriter(outputstream)); 
              out.write("java by piky2004@126.com"); 
              out.flush(); 
              BufferedReader in = new BufferedReader 
              (new InputStreamReader(sock.getInputStream())); 
              boolean more = true; 
              while(more) { 
                  String str = in.readLine(); 
                  if(str == null) more = false; 
                  else 
                  // 处理数据 
                   System.out.println(str); 
              } 
          in.close(); 
          } catch (IOException e) { 
              NetComm_Close(); 
              net_state = 0; 
          } 
          timer.start(); 
      } 
      public void NetComm_Close() 
      { 
          if(sock != null) 
          try{ 
              sock.close(); 
          } catch ( IOException e) { 
          } 
      } 
      public void actionPerformed(ActionEvent e) 
      { 
          if(net_state == 0) 
          NetComm_Init(); 
          else 
          NetComm_Data(); 
      }
    
                

    在上面的程序中,也可以为外部应用提供一个回调函数,以便在网络异常或恢复正常时通知应用。服务应用的网络通信类类似,可以放在同一类中。

  • 相关阅读:
    睡眠错误
    Linux中安装Mysql授权远程访问
    lamp安装
    MySQL 数据类型(Day41)
    MySQL 表操作 (Day40)
    MySQL之存储引擎(Day39)
    MySQL下载安装
    python并发编程之IO模型(Day38)
    同步锁,死锁现象与递归锁,信息量Semaphore.....(Day36)
    多线程并发练习(Day35)
  • 原文地址:https://www.cnblogs.com/taylor-longhua/p/4161613.html
Copyright © 2020-2023  润新知