Java调用和回调总结(2)

Java调用和回调总结(2)

---

调用的种类

调用有3种, 普通调用(同步调用), 异步调用, 异步回调.

三种调用的特点

普通调用: 也叫做**同步调用 **, 最常见的调用, 会造成阻塞.

异步调用 : 异步调用, 解决了同步调用阻塞的问题, 但是没有返回的结果.

异步回调 : 异步回调, 解决了阻塞, 还可以返回结果.

三者递进的关系从弱到强的如普通调用< 异步调用 < 异步回调, 三者之间最重要的区别其实就只有两点,1:这个调用是不是会造成主线程的阻塞, 2: 我们调用的时候, 可不可以返回执行的结果. 很明显,普通调用, 是会造成阻塞, 但是执行完毕之后, 我们可以立马就获得执行的结果! 但是由于有很多任务的执行时间是非常长的, 这样就会阻塞我们主线程的任务, 所以就导致异步调用的出现, 异步调用和同步调用区别就是, 同步调用阻塞,但是可以获得这个执行的结果, 异步调用不会阻塞, 但是无法得知这个执行的结果! 那么如何解决无法得知任务执行结果的问题呢? 那就是需要在执行的时候, 执行完了之后, 直接通知主线程, 通知主线程, 那就是要使用主线程所在的类的对象, 然后修改其表示执行结果的字段或者属性, 或者执行某个方法让外界得知, 就表示执行的结果已经被外界得知了.

同步和异步怎么解决？

同步会阻塞主线程, 因为我们执行的过程是线性, 线性是因为没有其他的执行线程, 只有一条, 因为同一个时间只有一条任务执行, 是独占的, 所以任务只能阻塞, 等这个任务执行完了才能去执行另一个任务!

异步呢? 异步不会阻塞, 就是因为它突破了只有一个线程的限制, 所以要异步, 就要创建多个线程, 那么在java 里面, 就创建多个Thread, 这样就可以实现异步了!

回调怎么理解?

不管是同步还是异步调用, 都是A调用B单线的调用, 但是这样的话, 比如我们在A线程之中调用B, 那么我们就无法知道B执行的结果, 或者是要让A等待很久, 才能让两个任务完成. 那么我们就要双向调用, 而不是单向调用, 这样的话, 可以双方调用 ,就可以知道结果了, 回调的方式, 一般是通过Interface接口来实现的, 但是也可以通过Class来实现, 但是一般还是通过Interface来实现, 我们需要面向接口来编程.

三种调用实例

同步调用

Teacher类

public class Teacher {
    private String name;

    private Student student;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Teacher() {
    }

    public Teacher(String name) {
        this.name = name;
    }

    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }

    // 教师给学生布置作业，然后学生做作业
    // public void assignHomework(Student s) throws InterruptedException {
    public void assignHomework() throws InterruptedException {
        student.doHomework();
        // 表示普通的调用，会阻塞主线程
        System.out.println("老师" + this.getName() + "我要去逛街了!");
    }
}

Student类

public class Student {
    private String name;
    private int id;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public Student() {
    }

    public Student(String name, int id) {
        this.name = name;
        this.id = id;
    }

    public void doHomework() throws InterruptedException {
        System.out.println("我是" + this.getName() + ", 正在写我的家庭作业!");
        Thread.currentThread().sleep(5000);
        System.out.println("我写完了!");
    }
}

HomeworkTest类

public class HomeworkTest {
    public static void main(String[] args) throws InterruptedException {
        Student student = new Student("张三", 1);
        Teacher teacher = new Teacher("小小仙女");
        teacher.setStudent(student);
        teacher.assignHomework();
    }
}

异步调用

EnglishTeacher类

public class EnglishTeacher {
    private String name;
    private LittleStudent student;

    public EnglishTeacher() {
    }

    public EnglishTeacher(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public LittleStudent getStudent() {
        return student;
    }

    public void setStudent(LittleStudent student) {
        this.student = student;
    }

    /**
     * 布置作业
     */
    public void assignHomework() {
        System.out.println(student.getName() + "你去做你的作业, 现在立刻!");
        // 异步调用
        student.doHomework();
        System.out.println("哈哈, 因为我作为一个老师, 要去逛街了!");
    }
}

LittleStudent类

public class LittleStudent {
    private String name;
    private int age;

    public LittleStudent() {
    }

    public LittleStudent(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    // 异步调用的关键, 可以防止阻塞发生, 在需要调用的这个方法之中, 新开一个线程, 就可以防止主线程阻塞了
    public void doHomework() {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(getName() + "我正在做我的工作");
                try {
                    Thread.currentThread().sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 但是此处没有说明做事情的时间, 没有回调的话, 调用者就不就知道任务到底完成了没有!
            }
        });
        t.start();
    }
}

EnglishHomeworkTest类

public class EnglishHomeworkTest {
    public static void main(String[] args) {
        EnglishTeacher teacher = new EnglishTeacher("小仙女儿");
        LittleStudent student = new LittleStudent("王二麻子", 7);
        teacher.setStudent(student);
        // 调用
        teacher.assignHomework();
    }
}

异步回调

1.使用类的方式实现

Boss类

public class Boss {
    private String name;
    private Employee employee;

    public Boss() {
    }

    public Boss(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Employee getEmployee() {
        return employee;
    }

    public void setEmployee(Employee employee) {
        this.employee = employee;
    }

    public void assignTask() {
        System.out.println(this.getName() + ", 作为老板, 我要去做个保健了, 你去干活!");
        // 让员工去干活
        employee.doTask();
        System.out.println(this.getName() + ", 作为老板, 我做保健了, 我回来了!");
    }

    public void getTaskResult() {
        System.out.println("完成了任务!");
    }
}

Employee类

public class Employee {
    private String name;
    private Boss boss;

    public Employee() {
    }

    public Employee(String name, Boss boss) {
        this.name = name;
        this.boss = boss;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Boss getBoss() {
        return boss;
    }

    public void setBoss(Boss boss) {
        this.boss = boss;
    }

    // 异步调用
    public void doTask() {
        // 开一个新的线程, 避免阻塞
        Runnable r = new Runnable() {
            @Override
            public void run() {
                // 做具体的业务
                long startTime = System.currentTimeMillis();
                try {
                    System.out.println("我是" + getName() + ", 老板啊! 我在玩命干活中!!!");
                    Thread.currentThread().sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                long endTime = System.currentTimeMillis();
                long costTime = endTime - startTime;
                System.out.println("这个结果是我自己知道的, 但是我不会给老板说! 实际上我花了" + costTime / 1000 + "ms");

                // 回调, 由此可以给出结果!
                boss.getTaskResult();
            }
        };
        new Thread(r).start();
    }
}

TaskTest类

public class TaskTest {
    public static void main(String[] args) {
        Boss boss = new Boss("大裤衩");
        Employee employee = new Employee("王二", boss);
        boss.setEmployee(employee);
        boss.assignTask();
        // employee.doTask();
    }
}

2.使用接口的方式实现, 推荐

BossCallback事件接口

interface BossCallback {
    // doEvent, 这就是一个回调通知的方法
    public void doEvent();
}

FoxBoss类

public class FoxBoss implements BossCallback {
    private String name;
    private FoxEmployee foxEmployee;

    public FoxBoss() {
    }

    public FoxBoss(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public FoxEmployee getFoxEmployee() {
        return foxEmployee;
    }

    public void setFoxEmployee(FoxEmployee foxEmployee) {
        this.foxEmployee = foxEmployee;
    }

    public void assignTask() {
        System.out.println(this.getName() + ", 作为老板, 我要去做个保健了, 你去干活!");
        // 让员工去干活
        foxEmployee.doTask();
        System.out.println(this.getName() + ", 作为老板, 我做保健了, 我回来了!");
    }

    @Override
    public void doEvent() {
        System.out.println("打电话给老板，告知已经完成工作了");
    }
}

FoxEmployee类

public class FoxEmployee {
    private String name;
    private BossCallback bossCallBack;

    public FoxEmployee() {
    }

    public FoxEmployee(String name, BossCallback bossCallBack) {
        this.name = name;
        this.bossCallBack = bossCallBack;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public BossCallback getBossCallback() {
        return bossCallBack;
    }

    public void setBossCallback(BossCallback bossCallBack) {
        this.bossCallBack = bossCallBack;
    }

    // 异步调用
    public void doTask() {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                // 做具体的业务
                long startTime = System.currentTimeMillis();
                try {
                    System.out.println("我是" + getName() + ", 老板啊! 我在玩命干活中!!!");
                    Thread.currentThread().sleep(8000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                long endTime = System.currentTimeMillis();
                long costTime = endTime - startTime;
                System.out.println("这个结果是我自己知道的, 但是我不会给老板说! 实际上我花了" + costTime / 1000 + "ms");

                // 回调, 由此可以给出结果!
                bossCallBack.doEvent();
            }
        };
        new Thread(r).start();
    }
}

FoxTaskTest类

public class FoxTaskTest {
    public static void main(String[] args) {
        FoxBoss boss = new FoxBoss("大裤衩");
        FoxEmployee employee = new FoxEmployee("王二", boss);
        boss.setFoxEmployee(employee);
        boss.assignTask();
    }
}

---

ref:

1.java回调函数，看完就懂, 2.Java接口回调机制详解, 3.Java回调机制解析, 4.异步调用的理解, 5.Java回调机制总结