码迷,mamicode.com
首页 > 编程语言 > 详细

Java回调函数的理解与实现

时间:2018-08-15 11:14:07      阅读:258      评论:0      收藏:0      [点我收藏+]

标签:运行时间   cut   oid   定义   too   tac   callback   ide   rgs   

回调函数,或简称回调,是指通过函数参数传递到其它代码的,某一块可执行代码的引用。这一设计允许了底层代码调用在高层定义的子程序。

在Java里面,我们使用接口来实现回调。举个例子

所谓的回调,就是程序员A写了一段程序(程序a),其中预留有回调函数接口,并封装好了该程序。程序员B要让a调用自己的程序b中的一个方法,于是,他通过a中的接口回调自己b中的方法。

举个例子:

 1.  首先定义一个类Caller,按照上面的定义就是程序员A写的程序a,这个类里面保存一个接口引用。

public class Caller {
    private MyCallInterface callInterface;
    
    public Caller() {
    }
    
    public void setCallFunc(MyCallInterface callInterface) {
        this.callInterface = callInterface;
    }
    
    public void call() {
        callInterface.printName();
    }
}

 2.  接口的定义,方便程序员B根据定义编写程序实现接口。

public interface MyCallInterface {
    public void  printName();
}

3.  第三是定义程序员B写的程序b

public class Client implements MyCallInterface {
 
    @Override
    public void printName() {
        System.out.println("This is the client printName method");
    }
}

4.  测试

public class Test {
    public static void main(String[] args) {
        Caller caller = new Caller();
        caller.setCallFunc(new Client());
        caller.call();
    }
}

这样我们可以看到程序a中保留有接口成员变量,使得程序a可以通过这个接口变量调用这个接口任意实现类的方法。而程序b被调用的方法就是回调函数。

 

接下来在看一个具体的实现:

下面使用java回调函数来实现一个测试函数运行时间的工具类:

如果我们要测试一个类的方法的执行时间,通常我们会这样做:

public   class  TestObject {  
    /**  
     * 一个用来被测试的方法,进行了一个比较耗时的循环  
     */   
    public   static   void  testMethod(){  
        for ( int  i= 0 ; i< 100000000 ; i++){  
              
        }  
    }  
    /**  
     * 一个简单的测试方法执行时间的方法  
     */   
    public   void  testTime(){  
        long  begin = System.currentTimeMillis(); //测试起始时间   
        testMethod(); //测试方法   
        long  end = System.currentTimeMillis(); //测试结束时间   
        System.out.println("[use time]:"  + (end - begin)); //打印使用时间   
    }  
      
    public   static   void  main(String[] args) {  
        TestObject test=new  TestObject();  
        test.testTime();  
    }  
}

下面我们来做一个函数实现相同功能但更灵活:

首先定一个回调接口:

public   interface  CallBack {  
    //执行回调操作的方法   
    void  execute();  
}  

然后再写一个工具类:

public   class  Tools {  
    /**  
     * 测试函数使用时间,通过定义CallBack接口的execute方法  
     * @param callBack  
     */   
    public   void  testTime(CallBack callBack) {  
        long  begin = System.currentTimeMillis(); //测试起始时间   
        callBack.execute(); ///进行回调操作   
        long  end = System.currentTimeMillis(); //测试结束时间   
        System.out.println("[use time]:"  + (end - begin)); //打印使用时间   
    }  
      
    public   static   void  main(String[] args) {  
        Tools tool = new  Tools();  
        tool.testTime(new  CallBack(){  
            //定义execute方法   
            public   void  execute(){  
                //这里可以加放一个或多个要测试运行时间的方法   
                TestObject.testMethod();  
            }  
        });  
    }  
}

一个待测试的,较耗时的方法:

public   class  TestObject {  
    /**  
     * 一个用来被测试的方法,进行了一个比较耗时的循环  
     */   
    public   static   void  testMethod(){  
        for ( int  i= 0 ; i< 100000000 ; i++){  
              
        }  
    }
}

这里我们没有写程序b去实现Callback接口,而是通过匿名内部类的方法来实现。同样也实现了回调函数。

 

之后我们看看为什么要使用回调函数:

所谓回调函数就是A调用了B,B在适当的时候又反回去调用A。多数时候因为是单线程,A没有必要等B来调用它,因为A在调用完B之后完全可以调用自己需要的操作。所以回调多见于事件驱动机制里。因为A在调用完B之后不知道B什么时候会完成,所以A不知道B什么时候会完成。而唯一知道B什么时候完成的当然是B自己了,所以当B完成的时候会通过一个回调函数通知A,自己已经完成了,这时候A才知道该进行下面的操作。如果不这样的话,A就只能不断地询问B是不是已经完成了(就是轮询),可见是效率非常低的,实现也很麻烦。

回调通常是在两个不同的线程间需要同步的情况下才出现的,但是很多时候又没有必要用信号量去进行真正的线程同步,因为会很复杂,而且没有必要。所以有了回调。至于回调要干的事情,当然是你自己决定了。

 

说一下同步回调和异步回调:

同步指的是调用一个方法,调用方要等待该方法所执行的任务完全执行完毕,然后控制权回到调用方;异步指的是调用一个方法,调用方不等该方法执行的任务完毕就返回,当任务执行完毕时会自动执行调用方传入的一块代码。

同步:

void runTask {
  doTask1()
  doTask2()
}

同步调用,执行完 doTask1 在执行 doTask2

异步

doTask1(new Callback() {
  void call() {
    doTask3()
  }
});
doTask2();

异步回调,会同时执行 doTask1 和 doTask2, 在执行完 doTask1 后执行 doTask3

同步调用适合执行耗时短的任务,异步回调适合执行耗时长的任务,而且调用它之后调用的任务没什么关系。

看一个异步回调的案例:

 回调接口类:

/**
 * 回调模式-回调接口类
 */
public interface CSCallBack {
    public void process(String status);
}

 模拟客户端:

/**
 * 回调模式-模拟客户端类
 */
public class Client implements CSCallBack {

    private Server server;

    public Client(Server server) {
        this.server = server;
    }

    public void sendMsg(final String msg){
        System.out.println("客户端:发送的消息为:" + msg);
        new Thread(new Runnable() {
            @Override
            public void run() {
                server.getClientMsg(Client.this,msg);
            }
        }).start();
        System.out.println("客户端:异步发送成功");
    }

    @Override
    public void process(String status) {
        System.out.println("客户端:服务端回调状态为:" + status);
    }
}

模拟服务端:

/**
 * 回调模式-模拟服务端类
 */
public class Server {

    public void getClientMsg(CSCallBack csCallBack , String msg) {
        System.out.println("服务端:服务端接收到客户端发送的消息为:" + msg);

        // 模拟服务端需要对数据处理
        try {
            Thread.sleep(5 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("服务端:数据处理成功,返回成功状态 200");
        String status = "200";
        csCallBack.process(status);
    }
}

 测试类:

/**
 * 回调模式-测试类
 */
public class CallBackTest {
    public static void main(String[] args) {
        Server server = new Server();
        Client client = new Client(server);

        client.sendMsg("Server,Hello~");
    }
}

 

Java回调函数的理解与实现

标签:运行时间   cut   oid   定义   too   tac   callback   ide   rgs   

原文地址:https://www.cnblogs.com/winterfells/p/9480140.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!