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

package TestObserver;

10年积累的成都网站建设、做网站经验，可以快速应对客户对网站的新想法和需求。提供各种问题对应的解决方案。让选择我们的客户得到更好、更有力的网络服务。我虽然不认识你，你也不认识我。但先做网站后付款的网站建设流程，更有定襄免费网站建设让你可以放心的选择与我们合作。

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回调和线程实现异步调用

软件模块之间的调用关系可以分为两大类:即同步调用和异步调用。在同步调用中,一段代码(主调方)调用另一段代码(被调方),主调方必须等待这段代码执行完成返回结果后,才能继续往下执行,所以,同步调用是一种阻塞式调用,主调方代码一直阻塞等待直到被调方返回为止。同步调用相对比较直观,也是大部分编程语言直接支持的一种调用方式。但是,同步调用在处理比较耗时的情况下会严重影响程序性能,影响人机交互的瞬时反应。例如,某个程序需要访问数据库获取大量数据,然后根据这些数据进行一系列处理,将处理结果显示在程序主窗口。由于数据库访问和大量数据的处理都是耗时的工作,在这个工作完成之前,处理结果迟迟不能显示,用户点击鼠标也不会立即得到响应,让用户感到整个程序显得很沉重。面对这样一些需要比较长时间才能完成的应用场景,我们需要采用一种非阻塞式调用方式,即异步调用方式

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("主线程内容"); } }

基本上和方法一没什么区别，只是这里使用了条件锁，两者的锁机制有所不同。

SpringBoot实现http请求的异步长轮询【2】— AsyncHandlerInterceptor方式

客户端调用服务端接口，服务端这个接口比较耗时。为了优化服务端的性能。

服务端收到servlet请求后，释放掉servlet占用的线程资源。开启一个异步线程去处理耗时的操作。当耗时操作处理完成后，将结果返回给客户端。

注意：在此期间，客户端和服务端的http链接并不会断开，客户端依旧苦苦等待响应数据；

可以使用接口AsyncHandlerInterceptor实现来拦截涉及异步处理的请求，而不是使用HandlerInterceptor。

HandlerInterceptorAdapter适配器，适配了AsyncHandlerInterceptor和HandlerInterceptor，推荐使用这个来实现。

上文说到，释放Servlet线程，交由指定的线程池去处理，那么如何去定义指定的线程池？

注意：方法返回的是Callable。

执行效果如下图所示：

SpringMVC-使用AsyncHandlerInterceptor拦截异步处理请求

网页标题：java异步轮询代码 java如何实现异步处理
标题链接：http://kswjz.com/article/ddgjgsi.html