1、同步调用
同步调用是最基本的调用方式，对象b中的方法直接调用对象a的方法，这个时候程序会等待对象a的方法执行完返回结果之后才会继续往下走。
代码如下：
public class A {
public void methodA()
{
System.out.println("this is class A method");
}
}
public class B {
public void methodB()
{
A a = new A();
a.methodA();
System.out.println("this is class B method");
}
}
public class Test {
public static void main(String[] args) {
B b = new B();
b.methodB();
}
}
结果：
this is class A method
this is class B method
2、异步调用
（一）线程方式
对象b中的方法调用对象a的方法，程序并不需要等待对象a的方法返回结果值，直接继续往下走。
代码如下：
public class A extends Thread{
@Override
public void run() {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("this is class A method");
}
}
public class B {
public void methodB()
{
A a = new A();
a.start();
System.out.println("this is class B method");
}
}
public class Test {
public static void main(String[] args) {
B b = new B();
b.methodB();
}
}
结果：
this is class B method
this is class A method
说明：异步调用我们通常采用多线程的方法来达到目的
（二）SpringBoot+@Async
开启异步，@EnableAsync 注解主要是为了扫描范围包下的所有 @Async注解
@EnableAsync
@SpringBootApplication
public class EhCacheStudyApplication {
public static void main(String[] args) {
SpringApplication.run(EhCacheStudyApplication.class, args);
}
}
创建异步任务，异步任务类代码：
@Component
public class MyAsyncTask {
@Async
public void task1() throws InterruptedException {
long currentTimeMillis = System.currentTimeMillis();
Thread.sleep(1000);
long currentTimeMillis1 = System.currentTimeMillis();
System.out.println("task1任务耗时：" + (currentTimeMillis1 - currentTimeMillis));
}
@Async
public void task2() throws InterruptedException {
long currentTimeMillis = System.currentTimeMillis();
Thread.sleep(2000);
long currentTimeMillis1 = System.currentTimeMillis();
System.out.println("task2任务耗时：" + (currentTimeMillis1 - currentTimeMillis));
}
@Async
public void task3() throws InterruptedException {
long currentTimeMillis = System.currentTimeMillis();
Thread.sleep(1000);
long currentTimeMillis1 = System.currentTimeMillis();
System.out.println("task3任务耗时：" + (currentTimeMillis1 - currentTimeMillis));
}
}
@RestController
public class AsyncTaskController {
@Autowired
private MyAsyncTask myAsyncTask;
@RequestMapping
public String doTask() throws InterruptedException {
long currentTimeMillis = System.currentTimeMillis();
myAsyncTask.task1();
myAsyncTask.task2();
myAsyncTask.task3();
long currentTimeMillis1 = System.currentTimeMillis();
System.out.println("task任务总耗时：" + (currentTimeMillis1 -currentTimeMillis));
return "task任务总耗时：" + (currentTimeMillis1 -currentTimeMillis);
}
}
启动项目，访问接口，查看后台输出结果：
3、回调
对象a的方法methodA（）中调用对象b的methodB（）方法，在对象b的methodB（）方法中反过来调用对象a的callBack（）方法，这个callBack（）方法称为回调函数，这种调用方法称为回调。
代码如下：
public class A {
public void methodA()
{
B b = new B();
b.methodB(new A());
System.out.println("this is class A method : methodA");
}
public void callBack()
{
System.out.println("this is class A method : callBack");
}
}
public class B {
public void methodB(A a)
{
System.out.println("this is class B method : methodB");
a.callBack();
}
}
public class Test {
public static void main(String[] args) {
A a = new A();
a.methodA();
}
}
运行结果：
this is class B method : methodB
this is class A method : callBack
this is class A method : methodA
注意：这里如果为了代码的扩展性更好，可以把类A与类B抽象出一个接口出来，然后用实现类去实现着两个接口，这样代码的扩展性会更好，也能满足更多的业务场景。
回调的核心在于：回调方将本身对象传给调用方，调用方在本身代码逻辑执行完之后，调用回调方的回调方法。
