欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Java基础9:解读Java回调机制

程序员文章站 2022-06-07 20:41:13
更多内容请关注微信公众号【Java技术江湖】这是一位阿里 Java 工程师的技术小站,作者黄小斜,专注 Java 相关技术:SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程,偶尔讲点Docker、ELK,同时也分享技术干货和学习经验,致力于Java全栈开发!(... ......

更多内容请关注微信公众号【java技术江湖】

这是一位阿里 java 工程师的技术小站,作者黄小斜,专注 java 相关技术:ssm、springboot、mysql、分布式、中间件、集群、linux、网络、多线程,偶尔讲点docker、elk,同时也分享技术干货和学习经验,致力于java全栈开发!(关注公众号后回复”资料“即可领取 3t 免费技术学习资源以及我我原创的程序员校招指南、java学习指南等资源)

Java基础9:解读Java回调机制

本文主要介绍了java中的回调机制,以及java多线程中类似回调的机制。

具体代码在我的github中可以找到

https://github.com/h2pl/mytech

文章首发于我的个人博客:

更多关于java后端学习的内容请到我的csdn博客上查看:

模块间的调用

本部分摘自https://www.cnblogs.com/xrq730/p/6424471.html

在一个应用系统中,无论使用何种语言开发,必然存在模块之间的调用,调用的方式分为几种:

(1)同步调用

同步调用是最基本并且最简单的一种调用方式,类a的方法a()调用类b的方法b(),一直等待b()方法执行完毕,a()方法继续往下走。这种调用方式适用于方法b()执行时间不长的情况,因为b()方法执行时间一长或者直接阻塞的话,a()方法的余下代码是无法执行下去的,这样会造成整个流程的阻塞。

Java基础9:解读Java回调机制

(2)异步调用

Java基础9:解读Java回调机制

异步调用是为了解决同步调用可能出现阻塞,导致整个流程卡住而产生的一种调用方式。类a的方法方法a()通过新起线程的方式调用类b的方法b(),代码接着直接往下执行,这样无论方法b()执行时间多久,都不会阻塞住方法a()的执行。

但是这种方式,由于方法a()不等待方法b()的执行完成,在方法a()需要方法b()执行结果的情况下(视具体业务而定,有些业务比如启异步线程发个微信通知、刷新一个缓存这种就没必要),必须通过一定的方式对方法b()的执行结果进行监听。

在java中,可以使用future+callable的方式做到这一点,具体做法可以参见我的这篇文章java多线程21:多线程下其他组件之cyclicbarrier、callable、future和futuretask。

(3)回调

Java基础9:解读Java回调机制

最后是回调,回调的思想是:

类a的a()方法调用类b的b()方法 类b的b()方法执行完毕主动调用类a的callback()方法 这样一种调用方式组成了上图,也就是一种双向的调用方式。

回调实例:tom做题

数学老师让tom做一道题,并且tom做题期间数学老师不用盯着tom,而是在玩手机,等tom把题目做完后再把答案告诉老师。

1 数学老师需要tom的一个引用,然后才能将题目发给tom。

2 数学老师需要提供一个方法以便tom做完题目以后能够将答案告诉他。

3 tom需要数学老师的一个引用,以便tom把答案给这位老师,而不是隔壁的体育老师。

回调接口,可以理解为老师接口

    //回调指的是a调用b来做一件事,b做完以后将结果告诉给a,这期间a可以做别的事情。
    //这个接口中有一个方法,意为b做完题目后告诉a时使用的方法。
    //所以我们必须提供这个接口以便让b来回调。
    //回调接口,
    public interface callback {
        void tellanswer(int res);
    }

数学老师类

    //老师类实例化回调接口,即学生写完题目之后通过老师的提供的方法进行回调。
    //那么学生如何调用到老师的方法呢,只要在学生类的方法中传入老师的引用即可。
    //而老师需要指定学生答题,所以也要传入学生的实例。
public class teacher implements callback{
    private student student;

    teacher(student student) {
        this.student = student;
    }

    void askproblem (student student, teacher teacher) {
        //main方法是主线程运行,为了实现异步回调,这里开启一个线程来操作
        new thread(new runnable() {
            @override
            public void run() {
                student.resolveproblem(teacher);
            }
        }).start();
        //老师让学生做题以后,等待学生回答的这段时间,可以做别的事,比如玩手机.\
        //而不需要同步等待,这就是回调的好处。
        //当然你可以说开启一个线程让学生做题就行了,但是这样无法让学生通知老师。
        //需要另外的机制去实现通知过程。
        // 当然,多线程中的future和callable也可以实现数据获取的功能。
        for (int i = 1;i < 4;i ++) {
            system.out.println("等学生回答问题的时候老师玩了 " + i + "秒的手机");
        }
    }

    @override
    public void tellanswer(int res) {
        system.out.println("the answer is " + res);
    }
}

学生接口

    //学生的接口,解决问题的方法中要传入老师的引用,否则无法完成对具体实例的回调。
    //写为接口的好处就是,很多个学生都可以实现这个接口,并且老师在提问题时可以通过
    //传入list<student>来聚合学生,十分方便。
public interface student {
    void resolveproblem (teacher teacher);
}

学生tom

public class tom implements student{

    @override
    public void resolveproblem(teacher teacher) {
        try {
            //学生思考了3秒后得到了答案,通过老师提供的回调方法告诉老师。
            thread.sleep(3000);
            system.out.println("work out");
            teacher.tellanswer(111);
        } catch (interruptedexception e) {
            e.printstacktrace();
        }
    }

测试类

public class test {
    public static void main(string[] args) {
        //测试
        student tom = new tom();
        teacher lee = new teacher(tom);
        lee.askproblem(tom, lee);
        //结果
//        等学生回答问题的时候老师玩了 1秒的手机
//        等学生回答问题的时候老师玩了 2秒的手机
//        等学生回答问题的时候老师玩了 3秒的手机
//        work out
//        the answer is 111
    }
}

多线程中的“回调”

java多线程中可以通过callable和future或futuretask结合来获取线程执行后的返回值。实现方法是通过get方法来调用callable的call方法获取返回值。

其实这种方法本质上不是回调,回调要求的是任务完成以后被调用者主动回调调用者的接口。而这里是调用者主动使用get方法阻塞获取返回值。

public class 多线程中的回调 {
    //这里简单地使用future和callable实现了线程执行完后
    public static void main(string[] args) throws executionexception, interruptedexception {
        executorservice executor = executors.newcachedthreadpool();
        future<string> future = executor.submit(new callable<string>() {
            @override
            public string call() throws exception {
                system.out.println("call");
                timeunit.seconds.sleep(1);
                return "str";
            }
        });
        //手动阻塞调用get通过call方法获得返回值。
        system.out.println(future.get());
        //需要手动关闭,不然线程池的线程会继续执行。
        executor.shutdown();

    //使用futuretask同时作为线程执行单元和数据请求单元。
    futuretask<integer> futuretask = new futuretask(new callable<integer>() {
        @override
        public integer call() throws exception {
            system.out.println("dasds");
            return new random().nextint();
        }
    });
    new thread(futuretask).start();
    //阻塞获取返回值
    system.out.println(futuretask.get());
}
@test
public void test () {
    callable callable = new callable() {
        @override
        public object call() throws exception {
            return null;
        }
    };
    futuretask futuretask = new futuretask(callable);

}
}