「java异步回调线程」Java异步回调
本篇文章给大家谈谈java异步回调线程，以及Java异步回调对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
如何用Java回调和线程实现异步调用
软件模块之间的调用关系可以分为两大类：即同步调用和异步调用。在同步调用中，一段代码（主调方）调用另一段代码（被调方），主调方必须等待这段代码执行完成返回结果后，才能继续往下执行，所以，同步调用是一种阻塞式调用，主调方代码一直阻塞等待直到被调方返回为止。同步调用相对比较直观，也是大部分编程语言直接支持的一种调用方式。但是，同步调用在处理比较耗时的情况下会严重影响程序性能，影响人机交互的瞬时反应。例如，某个程序需要访问数据库获取大量数据，然后根据这些数据进行一系列处理，将处理结果显示在程序主窗口。由于数据库访问和大量数据的处理都是耗时的工作，在这个工作完成之前，处理结果迟迟不能显示，用户点击鼠标也不会立即得到响应，让用户感到整个程序显得很沉重。面对这样一些需要比较长时间才能完成的应用场景，我们需要采用一种非阻塞式调用方式，即异步调用方式。在异步调用中，主调方调用被调方后，不等待对方返回结果就继续执行后续代码，被调方执行完毕后，通过某种手段通知调用方：结果已经出来，请酌情处理。我们可以对上面的例子改用异步调用将问题轻松化解：把整个耗时的工作放进一个单独的线程，由主调方启动此线程后继续执行后续代码，线程在背后悄悄地处理费时的工作，当工作完成，采用回调的方式通知主调方工作完成，主调方将结果显示在主窗口。经过这样的处理，主界面继续进行自己的工作而不必死等，就不会造成界面响应迟钝。
在实现异步调用机制时，除了线程之外，还要用到回调。回调是一种双向调用，也就是，被调方在被调用时也会调用主调方的代码。在异步调用中，被调方需要在工作完成时通知主调方，即调用主调方的接口，这一机制通过回调实现。回调和异步调用的关系非常紧密，回调是异步调用的基础[1]。
本文理论联系实际，首先阐述如何使用Java实现回调机制，然后进一步阐述使用Java回调和线程实现异步调用，最后，阐述在异步调用中如何处理超时问题。
1 Java回调机制的实现方法
实现Java回调，需要做如下三件事情：
（1）定义一个回调接口CallbackInterface
接口中声明回调方法handle，如图1所示，回调方法就是一个普通的方法，接收一个消息字符串或者一个封装了数据的事件。
（2）定义一个类实现回调接口
这个类其实就是消息接收者和处理者，也就是调用方，回调方法是消息发生时实际处理消息的方法，此处简化为一条打印语句。
（3）定义消息通知者
消息通知者也就是被调用方必须具备两种能力，第一，它必须知道谁是消息接收者，第二，当消息发生时，它能够回调这些接收者的回调方法。为了获得这两种能力，消息通知者首先必须提供一个注册方法register， 通过注册的方式来注册多个对此消息或事件感兴趣的对象。然后提供一个消息通知方法notifyMessage，在这个方法中调用所有消息接收者的回调方法。具体代码如图3所示。
比如用一个可变数组List用于保存消息接收者，注册的过程实际上是将消息接收者添加到这个数组，以备在需要通知消息的时候调用这些消息接收者的回调方法。
使用Java回调和线程实现异步调用
线程是一个独立的执行流，其本质是程序中一段并发执行的代码。在异步调用机制中引入线程，在线程中完成耗时的工作，其目的是让调用方的主线程继续执行后续代码而不需要等待被调方的结果返回。由于不需要等待，这样我们就等于同时做了两件事情，而这两件事情分别是在不同的执行流中执行，主调者在当前的主线程中执行，被调者在另外一个线程中执行，因此提高了程序的效率，避免了界面的响应迟钝。当被调者执行完成后，仍然采用回调通知主调者。
例如 LongTimeWorker是一个用于完成耗时工作的线程，同时又是消息通知者。其耗时工作在run方法中完成，另外提供一个注册方法register， 和一个消息通知方法notifyMessage，在run方法的最后，即耗时工作完成以后，调用notifyMessage将消息广播出去。
3 异步调用中超时问题的处理
异步调用通常都要加入超时机制，因为我们总是希望在一个指定的时间范围内返回一个结果，即使没有得到结果也该有个超时通知。这时我们需要使用“限时线程回调方式”，它在原有线程回调的基础上加上一个计时器Timer以计算消耗的时间，如果时间期限到了任务还没有执行完成即中断线程，并将超时消息广播出去。LongTimeWorker类需要修改部分的代码如图8和图9所示。
首先LongTimeWorker线程类增加了一个构造方法，其参数是超时时间timeout，构造方法的主要任务是创建一个定时器，每秒钟计时一次，若超时时间到则终止本线程，并广播超时消息。LongTimeWorker线程类的第二个改变发生在其run方法中，线程一启动立即开始计时，完成工作后停止计时，并广播消息。
4 结束语
异步调用是一种非阻塞式调用方式，用于在处理比较耗时的任务时保证程序性能不受到影响。实现异步调用的关键在于要解决三个技术难题，它们分别是程序阻塞问题、异步消息的传递问题和超时问题。本文介绍的方法采用并发线程、回调机制和计时器使上述问题得到了圆满解决。
java 异步调用方法
1. 使用wait和notify方法
这个方法其实是利用了锁机制，直接贴代码:
public class Demo1 extends BaseDemo{ private final Object lock = new Object(); @Override public void callback(long response) { System.out.println("得到结果"); System.out.println(response); System.out.println("调用结束"); synchronized (lock) { lock.notifyAll(); } } public static void main(String[] args) { Demo1 demo1 = new Demo1(); demo1.call(); synchronized (demo1.lock){ try { demo1.lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("主线程内容"); } }
可以看到在发起调用后，主线程利用wait进行阻塞，等待回调中调用notify或者notifyAll方法来进行唤醒。注意，和大家认知的一样，这里wait和notify都是需要先获得对象的锁的。在主线程中最后我们打印了一个内容，这也是用来验证实验结果的，如果没有wait和notify，主线程内容会紧随调用内容立刻打印;而像我们上面的代码，主线程内容会一直等待回调函数调用结束才会进行打印。
没有使用同步操作的情况下，打印结果:发起调用 调用返回 主线程内容 得到结果 1 调用结束
而使用了同步操作后:
发起调用 调用返回 得到结果 9 调用结束 主线程内容2. 使用条件锁
和方法一的原理类似:
public class Demo2 extends BaseDemo { private final Lock lock = new ReentrantLock(); private final Condition con = lock.newCondition(); @Override public void callback(long response) { System.out.println("得到结果"); System.out.println(response); System.out.println("调用结束"); lock.lock(); try { con.signal(); }finally { lock.unlock(); } } public static void main(String[] args) { Demo2 demo2 = new Demo2(); demo2.call(); demo2.lock.lock(); try { demo2.con.await(); } catch (InterruptedException e) { e.printStackTrace(); }finally { demo2.lock.unlock(); } System.out.println("主线程内容"); } }
基本上和方法一没什么区别，只是这里使用了条件锁，两者的锁机制有所不同。
java常见的几种调用机制（同步调用，异步调用
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
说明：异步调用我们通常采用多线程的方法来达到目的
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抽象出一个接口出来，然后用实现类去实现着两个接口，这样代码的扩展性会更好，也能满足更多的业务场景。
回调的核心在于：回调方将本身对象传给调用方，调用方在本身代码逻辑执行完之后，调用回调方的回调方法。
Java多线程实现异步调用
在JAVA平台 实现异步调用的角色有如下三个角色:调用者 提货单 真实数据一个调用者在调用耗时操作 不能立即返回数据时 先返回一个提货单 然后在过一断时间后凭提货单来获取真正的数据 去蛋糕店买蛋糕 不需要等蛋糕做出来（假设现做要很长时间） 只需要领个提货单就可以了（去干别的事情） 等到蛋糕做好了 再拿提货单取蛋糕就可以了 public class Main { public static void main(String[] args) {
System out println( main BEGIN );
Host host = new Host();
Data data = host request( A );
Data data = host request( B );
Data data = host request( C );
System out println( main otherJob BEGIN );
try {
Thread sleep( );
} catch (InterruptedException e) {
}
System out println( main otherJob END );
System out println( data = + data getContent());
System out println( data = + data getContent());
System out println( data = + data getContent());
System out println( main END );
}
}
这里的main类就相当于 顾客 host就相当于 蛋糕店 顾客向 蛋糕店 定蛋糕就相当于 发请求request 返回的数据data是FutureData的实例 就相当于提货单 而不是真正的 蛋糕 在过一段时间后（sleep一段时间后） 调用data getContent() 也就是拿提货单获取执行结果
下面来看一下 顾客定蛋糕后 蛋糕店做了什么
public class Host {
public Data request(final int count final char c) {
System out println( request( + count + + c + ) BEGIN );
// ( ) 建立FutureData的实体
final FutureData future = new FutureData();
// ( ) 为了建立RealData的实体 启动新的线程
new Thread() {
public void run() {
//在匿名内部类中使用count future c
RealData realdata = new RealData(count c);
future setRealData(realdata);
}
} start();
System out println( request( + count + + c + ) END );
// ( ) 取回FutureData实体 作为传回值
return future;
}
}
host( 蛋糕店 )在接到请求后 先生成了 提货单 FutureData的实例future 然后命令 蛋糕师傅 RealData去做蛋糕 realdata相当于起个线程去做蛋糕了 然后host返回给顾客的仅仅是 提货单 future 而不是蛋糕 当蛋糕做好后 蛋糕师傅才能给对应的 提货单 蛋糕 也就是future setRealData(realdata)
下面来看看蛋糕师傅是怎么做蛋糕的
建立一个字符串 包含count个c字符 为了表现出犯法需要花费一些时间 使用了sleep
public class RealData implements Data { private final String content;
public RealData(int count char c) {
System out println( making RealData( + count + + c + ) BEGIN );
char[] buffer = new char[count];
for (int i = ; i count; i++) {
buffer[i] = c;
try {
Thread sleep( );
} catch (InterruptedException e) {
}
}
System out println( making RealData( + count + + c + ) END );
ntent = new String(buffer);
}
public String getContent() {
return content;
}
}
现在来看看 提货单 future是怎么与蛋糕 content 对应的:
public class FutureData implements Data { private RealData realdata = null;
private boolean ready = false;
public synchronized void setRealData(RealData realdata) {
if (ready) {
return; // 防止setRealData被调用两次以上
}
this realdata = realdata;
this ready = true;
notifyAll();
}
public synchronized String getContent() {
while (!ready) {
try {
wait();
} catch (InterruptedException e) {
}
}
return realdata getContent();
}
}
顾客做完自己的事情后 会拿着自己的 提货单 来取蛋糕
System out println( data = + data getContent());
这时候如果蛋糕没做好 就只好等了
while (!ready) { try {
wait();
} catch (InterruptedException e) {
}
//等做好后才能取到
return realdata getContent();
程序分析
对于每个请求 host都会生成一个线程 这个线程负责生成顾客需要的 蛋糕 在等待一段时间以后 如果蛋糕还没有做好 顾客还必须等待 直到 蛋糕被做好 也就是
future setRealData(realdata); 执行以后 顾客才能拿走蛋糕
每个线程只是专门负责制作特定顾客所需要的 蛋糕 也就是顾客A对应着蛋糕师傅A 顾客B对应着蛋糕师傅B 即使顾客B的蛋糕被先做好了 顾客A也只能等待蛋糕师傅A把蛋糕做好 换句话说 顾客之间没有竞争关系
lishixinzhi/Article/program/Java/gj/201311/27425
JAVA如何实现异步回调
FutureTaskString futureTask=new FutureTask(new CallableString() {
@Override
public String call() throws Exception {
// TODO Auto-generated method stub
return "回调完成";
}
});
try {
String str=futureTask.get();
if(str.equals("回调完成"))
System.out.println("异步任务完成!");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ExecutionException e) {
// TODO Auto-generated catch block
e.printStackTrace(); }
java异步回调线程的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于Java异步回调、java异步回调线程的信息别忘了在本站进行查找喔。