如何用Java回调和线程实现异步调用

软件模块之间的调用关系可以分为两大类：即同步调用和异步调用。在同步调用中，一段代码（主调方）调用另一段代码（被调方），主调方必须等待这段代码执行完成返回结果后，才能继续往下执行，所以，同步调用是一种阻塞式调用，主调方代码一直阻塞等待直到被调方返回为止。同步调用相对比较直观，也是大部分编程语言直接支持的一种调用方式。但是，同步调用在处理比较耗时的情况下会严重影响程序性能，影响人机交互的瞬时反应。例如，某个程序需要访问数据库获取大量数据，然后根据这些数据进行一系列处理，将处理结果显示在程序主窗口。由于数据库访问和大量数据的处理都是耗时的工作，在这个工作完成之前，处理结果迟迟不能显示，用户点击鼠标也不会立即得到响应，让用户感到整个程序显得很沉重。面对这样一些需要比较长时间才能完成的应用场景，我们需要采用一种非阻塞式调用方式，即异步调用方式。在异步调用中，主调方调用被调方后，不等待对方返回结果就继续执行后续代码，被调方执行完毕后，通过某种手段通知调用方：结果已经出来，请酌情处理。我们可以对上面的例子改用异步调用将问题轻松化解：把整个耗时的工作放进一个单独的线程，由主调方启动此线程后继续执行后续代码，线程在背后悄悄地处理费时的工作，当工作完成，采用回调的方式通知主调方工作完成，主调方将结果显示在主窗口。经过这样的处理，主界面继续进行自己的工作而不必死等，就不会造成界面响应迟钝。

我们提供的服务有：成都网站设计、成都做网站、外贸网站建设、微信公众号开发、网站优化、网站认证、胶州ssl等。为成百上千家企事业单位解决了网站和推广的问题。提供周到的售前咨询和贴心的售后服务，是有科学管理、有技术的胶州网站制作公司

在实现异步调用机制时，除了线程之外，还要用到回调。回调是一种双向调用，也就是，被调方在被调用时也会调用主调方的代码。在异步调用中，被调方需要在工作完成时通知主调方，即调用主调方的接口，这一机制通过回调实现。回调和异步调用的关系非常紧密，回调是异步调用的基础[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怎么同步发送及异步发送短信例子解析

发送短信的接口

根据自己的情况选择服务商。

开发文档

从开发文档中我们可以看到. 可以直接使用http请求也可以使用WebService请求发送短信. 由于DEMO文件夹下的java和jsp文件夹中的代码都是使用http请求发送短信. 所以这里就不再细说了, 我们使用WebService的方式演示发送短信.

生成客户端代码

从接口文档中我们知道它的WebService的WSDL的url为: 那么我们可以执行下面的命令生成客户端代码:

wsimport -keep

其中wsimport是JDK自带的工具, -keep url选项是"保留生成的文件". 该命令会在当前目录下生成sms.cn.ihuyi._106包, 以及众多的类. 接下来开始编写我们自己的代码.

定义接口

为了方便, 这里我们首先定义一个接口:

Sms.java

public interface Sms {

/**

* 向mobile发送短信, 内容为message

* 

* @param mobile 手机号

* @param message 短信内容

* @return 成功返回-1, 否则返回其他值

*/

int sendMessage(String mobile, String message);

}

这个接口很简单, 只有一个方法. 这个方法用来发送短信.

同步发送短信

接下来我们首先实现一个同步发送短信的类:

IhuyiSmsImpl.java

public class IhuyiSmsImpl implements Sms {

private String account;

private String password;

public void setAccount(String account) {

this.account = account;

}

public void setPassword(String password) {

this.password = password;

}

@Override

public int sendMessage(String mobile, String message) {

cn.ihuyi._106.Sms factory = new cn.ihuyi._106.Sms();

SmsSoap smsSoap = factory.getSmsSoap();

SubmitResult submit = smsSoap.submit(account, password, mobile, message);

int code = submit.getCode();

if(code == 2){

return -1;

}

System.out.println("发送短信失败, code:" + code);

return code;

}

}

异步发送短信

由于发送短信涉及到网络通信, 因此sendMessage方法可能会有一些延迟. 为了改善用户体验, 我们可以使用异步发送短信的方法. 原理很简单: 如果用户请求发送短信, 我们不是直接调用IhuyiSmsImpl的sendMessage方法, 而是将请求保存起来(生产者), 然后告诉用户: 短信发送成功. 之后有若干个消费者取出任务, 调用sendMessage方法发送短信.

这里, 我使用线程池完成上面的任务:

AsyncSmsImpl.java

public class AsyncSmsImpl implements Sms {

public Sms sendSms;

private ExecutorService executorService = Executors.newFixedThreadPool(3);

public void setSendSms(Sms sendSms) {

this.sendSms = sendSms;

}

@Override

public int sendMessage(String mobile, String message) {

try {

executorService.submit(() - sendSms.sendMessage(mobile, message));

}

catch(Exception e) {

Sysemt.out.println("提交任务时发生错误" + e);

return 0;

}

return -1;

}

public void destroy(){

try{

executorService.shutdown();

}

catch(Exception e){}

}

}

在第17行, 我们获得远程对象的一个代理对象. 之后就可以通过这个代理对象进行发送短信, 查询账户余额等操作.

第18行, 使用该代理对象的submit方法提交了短信内容. 该方法的参数信息及返回值含义在接口文档中有详细的说明.

第19行我们获得了结果的状态码. 根据文档上的说明, 状态码为2说明提交成功. 简单起见, 这里我们只关注提交成功的情况. 需要注意的是, 状态码为2只是说明提交成功. 根据官网上的"3-5秒内响应、100%到达", 我们可以推测. 如果提交成功, 那么基本上3-5秒内,短信就会发送成功, 根据用户的网络情况, 可能稍有延迟用户就可以收到短信.

使用这段代码发送短信也很简单, 直接new一个对象, 设置好账号和密码就可以发送短信了.

代码很简单, 直接将Sms接口的sendMessage(mobile, message)方法作为一个任务加到线程池的任务队列中. 这样等到有空闲线程时, 就会执行sendSms.sendMessage(mobile, message)发送短信. 这里我们假设只要保存到线程池就可以成功发送短信. 因为发送失败的情况实际上很罕见.

java 异步编程

用异步输入输出流编写Socket进程通信程序

在Merlin中加入了用于实现异步输入输出机制的应用程序接口包：java.nio（新的输入输出包，定义了很多基本类型缓冲(Buffer)），java.nio.channels(通道及选择器等，用于异步输入输出)，java.nio.charset（字符的编码解码）。通道(Channel)首先在选择器(Selector)中注册自己感兴趣的事件，当相应的事件发生时，选择器便通过选择键(SelectionKey)通知已注册的通道。然后通道将需要处理的信息，通过缓冲（Buffer）打包，编码/解码,完成输入输出控制。

通道介绍：

这里主要介绍ServerSocketChannel和 SocketChannel.它们都是可选择的(selectable)通道，分别可以工作在同步和异步两种方式下（注意，这里的可选择不是指可以选择两种工作方式，而是指可以有选择的注册自己感兴趣的事件）。可以用channel.configureBlocking(Boolean )来设置其工作方式。与以前版本的API相比较，ServerSocketChannel就相当于ServerSocket(ServerSocketChannel封装了ServerSocket),而SocketChannel就相当于Socket（SocketChannel封装了Socket）。当通道工作在同步方式时，编程方法与以前的基本相似，这里主要介绍异步工作方式。

所谓异步输入输出机制，是指在进行输入输出处理时，不必等到输入输出处理完毕才返回。所以异步的同义语是非阻塞（None Blocking）。在服务器端，ServerSocketChannel通过静态函数open()返回一个实例serverChl。然后该通道调用serverChl.socket().bind()绑定到服务器某端口，并调用register（Selector sel, SelectionKey.OP_ACCEPT）注册OP_ACCEPT事件到一个选择器中（ServerSocketChannel只可以注册OP_ACCEPT事件）。当有客户请求连接时，选择器就会通知该通道有客户连接请求，就可以进行相应的输入输出控制了；在客户端，clientChl实例注册自己感兴趣的事件后（可以是OP_CONNECT,OP_READ,OP_WRITE的组合），调用clientChl.connect(InetSocketAddress )连接服务器然后进行相应处理。注意，这里的连接是异步的，即会立即返回而继续执行后面的代码。

选择器和选择键介绍：

选择器（Selector）的作用是：将通道感兴趣的事件放入队列中，而不是马上提交给应用程序，等已注册的通道自己来请求处理这些事件。换句话说，就是选择器将会随时报告已经准备好了的通道，而且是按照先进先出的顺序。那么，选择器是通过什么来报告的呢？选择键(SelectionKey)。选择键的作用就是表明哪个通道已经做好了准备，准备干什么。你也许马上会想到，那一定是已注册的通道感兴趣的事件。不错，例如对于服务器端serverChl来说，可以调用key.isAcceptable()来通知serverChl有客户端连接请求。相应的函数还有：SelectionKey.isReadable(),SelectionKey.isWritable()。一般的，在一个循环中轮询感兴趣的事件（具体可参照下面的代码）。如果选择器中尚无通道已注册事件发生，调用Selector.select()将阻塞，直到有事件发生为止。另外，可以调用selectNow()或者select(long timeout)。前者立即返回，没有事件时返回0值；后者等待timeout时间后返回。一个选择器最多可以同时被63个通道一起注册使用。

应用实例：

下面是用异步输入输出机制实现的客户/服务器实例程序――程序清单1（限于篇幅，只给出了服务器端实现，读者可以参照着实现客户端代码）：

程序类图

public class NBlockingServer {

int port = 8000;

int BUFFERSIZE = 1024;

Selector selector = null;

ServerSocketChannel serverChannel = null;

HashMap clientChannelMap = null;//用来存放每一个客户连接对应的套接字和通道

public NBlockingServer( int port ) {

this.clientChannelMap = new HashMap();

this.port = port;

}

public void initialize() throws IOException {

//初始化，分别实例化一个选择器，一个服务器端可选择通道

this.selector = Selector.open();

this.serverChannel = ServerSocketChannel.open();

this.serverChannel.configureBlocking(false);

InetAddress localhost = InetAddress.getLocalHost();

InetSocketAddress isa = new InetSocketAddress(localhost, this.port );

this.serverChannel.socket().bind(isa);//将该套接字绑定到服务器某一可用端口

}

//结束时释放资源

public void finalize() throws IOException {

this.serverChannel.close();

this.selector.close();

}

//将读入字节缓冲的信息解码

public String decode( ByteBuffer byteBuffer ) throws

CharacterCodingException {

Charset charset = Charset.forName( "ISO-8859-1" );

CharsetDecoder decoder = charset.newDecoder();

CharBuffer charBuffer = decoder.decode( byteBuffer );

String result = charBuffer.toString();

return result;

}

//监听端口，当通道准备好时进行相应操作

public void portListening() throws IOException, InterruptedException {

//服务器端通道注册OP_ACCEPT事件

SelectionKey acceptKey =this.serverChannel.register( this.selector,

SelectionKey.OP_ACCEPT );

//当有已注册的事件发生时,select()返回值将大于0

while (acceptKey.selector().select() 0 ) {

System.out.println("event happened");

//取得所有已经准备好的所有选择键

Set readyKeys = this.selector.selectedKeys();

//使用迭代器对选择键进行轮询

Iterator i = readyKeys.iterator();

while (i

else if ( key.isReadable() ) {//如果是通道读准备好事件

System.out.println("Readable");

//取得选择键对应的通道和套接字

SelectableChannel nextReady =

(SelectableChannel) key.channel();

Socket socket = (Socket) key.attachment();

//处理该事件，处理方法已封装在类ClientChInstance中

this.readFromChannel( socket.getChannel(),

(ClientChInstance)

this.clientChannelMap.get( socket ) );

}

else if ( key.isWritable() ) {//如果是通道写准备好事件

System.out.println("writeable");

//取得套接字后处理，方法同上

Socket socket = (Socket) key.attachment();

SocketChannel channel = (SocketChannel)

socket.getChannel();

this.writeToChannel( channel,"This is from server!");

}

}

}

}

//对通道的写操作

public void writeToChannel( SocketChannel channel, String message )

throws IOException {

ByteBuffer buf = ByteBuffer.wrap( message.getBytes() );

int nbytes = channel.write( buf );

}

//对通道的读操作

public void readFromChannel( SocketChannel channel, ClientChInstance clientInstance )

throws IOException, InterruptedException {

ByteBuffer byteBuffer = ByteBuffer.allocate( BUFFERSIZE );

int nbytes = channel.read( byteBuffer );

byteBuffer.flip();

String result = this.decode( byteBuffer );

//当客户端发出”@exit”退出命令时，关闭其通道

if ( result.indexOf( "@exit" ) = 0 ) {

channel.close();

}

else {

clientInstance.append( result.toString() );

//读入一行完毕，执行相应操作

if ( result.indexOf( "\n" ) = 0 ){

System.out.println("client input"+result);

clientInstance.execute();

}

}

}

//该类封装了怎样对客户端的通道进行操作，具体实现可以通过重载execute()方法

public class ClientChInstance {

SocketChannel channel;

StringBuffer buffer=new StringBuffer();

public ClientChInstance( SocketChannel channel ) {

this.channel = channel;

}

public void execute() throws IOException {

String message = "This is response after reading from channel!";

writeToChannel( this.channel, message );

buffer = new StringBuffer();

}

//当一行没有结束时，将当前字窜置于缓冲尾

public void append( String values ) {

buffer.append( values );

}

}

//主程序

public static void main( String[] args ) {

NBlockingServer nbServer = new NBlockingServer(8000);

try {

nbServer.initialize();

} catch ( Exception e ) {

e.printStackTrace();

System.exit( -1 );

}

try {

nbServer.portListening();

}

catch ( Exception e ) {

e.printStackTrace();

}

}

}

程序清单1

小结：

从以上程序段可以看出，服务器端没有引入多余线程就完成了多客户的客户/服务器模式。该程序中使用了回调模式(CALLBACK)。需要注意的是，请不要将原来的输入输出包与新加入的输入输出包混用，因为出于一些原因的考虑，这两个包并不兼容。即使用通道时请使用缓冲完成输入输出控制。该程序在Windows2000,J2SE1.4下，用telnet测试成功。

求 JAVA 异步观察者模式 的源代码（完整的），不要同步的，好的给加分

package TestObserver;

import java.util.Iterator;

import java.util.Vector;

/**

*

* @author Seastar

*/

interface Observed {

public void addObserver(Observer o);

public void removeObserver(Observer o);

public void update();

}

interface Observer {

public void takeAction();

}

class Invoker {

private Observer o;

Handler handler;

public Invoker(Observer o) {

new Handler();

this.o = o;

}

private class Handler extends Thread {

public Handler() {

handler = this;

}

@Override

public void run() {

o.takeAction();

}

}

public boolean TestSameObserver(Observer o) {

return o == this.o;

}

public void invoke() {

handler.start();

}

}

class ObservedObject implements Observed {

private VectorInvoker observerList = new VectorInvoker();

public void addObserver(Observer o) {

observerList.add(new Invoker(o));

}

public void removeObserver(Observer o) {

IteratorInvoker it = observerList.iterator();

while (it.hasNext()) {

Invoker i = it.next();

if (i.TestSameObserver(o)) {

observerList.remove(i);

break;

}

}

}

public void update() {

for (Invoker i : observerList) {

i.invoke();

}

}

}

class ObserverA implements Observer {

public void takeAction() {

System.out.println("I am Observer A ,state changed ,so i have to do something");

}

}

class ObserverB implements Observer {

public void takeAction() {

System.out.println("I am Observer B ,i was told to do something");

}

}

class ObserverC implements Observer {

public void takeAction() {

System.out.println("I am Observer C ,I just look ,and do nothing");

}

}

public class Main {

/**

* @param args the command line arguments

*/

public static void main(String[] args) {

ObserverA a = new ObserverA();

ObserverB b = new ObserverB();

ObserverC c = new ObserverC();

ObservedObject oo = new ObservedObject();

oo.addObserver(a);

oo.addObserver(b);

oo.addObserver(c);

for (int i = 0; i 5; ++i) {

oo.addObserver(new Observer() {

public void takeAction() {

System.out.println("我是山寨观察者"+"，谁敢拦我");

}

});

}

//sometime oo changed ,so it calls update and informs all observer

oo.update();

}

}

观察者模式的精髓在于注册一个观察者观测可能随时变化的对象，对象变化时就会自动通知观察者，

这样在被观测对象影响范围广，可能引起多个类的行为改变时很好用，因为无需修改被观测对象的代码就可以增加被观测对象影响的类，这样的设计模式使得代码易于管理和维护，并且减少了出错几率

至于异步机制实际是个噱头，可以有观测对象来实现异步，也可以有观察者自身实现，这个程序实际是观测对象实现了异步机制，方法是在观察者类外包装了一层invoker类

java队列实现异步执行

在整个思路上要调整一下

1、会有很多线程给一个队列上添加任务

2、有一个或者多个线程逐个执行队列的任务

考虑一下几点：

1、没有任务时，队列执行线程处于等待状态

2、添加任务时，激活队列执行线程，全部run起来，首先抢到任务的执行，其他全部wait

给个小例子吧

package org;

import java.util.LinkedList;

import java.util.List;

public class Queues {

public static ListTask queue = new LinkedListTask();

/**

 * 假如 参数o 为任务

 * @param o

 */

public static void add (Task t){

synchronized (Queues.queue) {

Queues.queue.add(t); //添加任务

Queues.queue.notifyAll();//激活该队列对应的执行线程，全部Run起来

}

}

static class Task{

public void test(){

System.out.println("我被执行了");

}

}

}

package org;

import java.util.List;

public class Exec implements Runnable{

@Override

public void run() {

while(true){

synchronized (Queues.queue) {

while(Queues.queue.isEmpty()){ //

try {

Queues.queue.wait(); //队列为空时，使线程处于等待状态

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("wait...");

}

Queues.Task t= Queues.queue.remove(0); //得到第一个

t.test(); //执行该任务

System.out.println("end");

}

}

}

public static void main(String[] args) {

Exec e = new Exec();

for (int i = 0; i  2; i++) {

new Thread(e).start(); //开始执行时，队列为空，处于等待状态

}

//上面开启两个线程执行队列中的任务，那就是先到先得了

//添加一个任务测试

Queues.Task t =new Queues.Task();

Queues.add(t); //执行该方法，激活所有对应队列，那两个线程就会开始执行啦

}

}

上面的就是很简单的例子了

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异步接口代码 java异步代码块
文章分享：http://azwzsj.com/article/doosjss.html