「java接口异步化」java异步编程实战
本篇文章给大家谈谈java接口异步化，以及java异步编程实战对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
- 1、Java多线程实现异步调用
- 2、java 调用支付接口为什么异步
- 3、java同步和异步的区别
- 4、如何用JAVA实现异步信息处理
- 5、java常见的几种调用机制（同步调用，异步调用
- 6、同步接口和异步接口的区别
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 调用支付接口为什么异步
在做java版本的支付宝接口的时候,最初是遇到了这样的问题,就是说,在直接的扫码支付,或者是直接的登录账号支付,是没有问题的,
但是,在这样的一种情况下是出现了一个问题,
我web端调用支付宝接口进行支付，一般都是支付成功之后，获得支付成功信息，然后同时去更改我本地订单状态（已付款）。
但是有一种情况是这样的：
调用支付宝接口，你输入账号密码之后， 在支付宝最后一步你不去点确认付款。直接退出（相当于你没有付款）。
然后，你用自己的手机支付宝客户端打开，你会看到有一个未付款的订单（也就是刚才你没付款但生成的订单）~这个时候 如果你去付款了，付款成功之后，就不可能调到我的web端呀？这样我就不能更改我本地的订单状态了。
想问下，大家遇到这种情况是怎么处理的？
有人说，每10秒钟通过订单号去支付宝查询并得到该订单状态。这种方法貌似可以，但是我百度了半天没有见到如何 根据订单号去查询订单状态啊！！！ 支付宝的接口我有（Danbao担保）。不太会用。
希望大神给予指点！！！在线坐等，感激万分！！！
这个问题是来自一位博友,最开始也是没有意识到什么问题,为什么是收到钱了,但是却是没有调用自己的逻辑代码,
在看到了这位博友的问题之后,才是发现了自己的问题所在,所以在这里感谢一下,
然后是想说的是,知道了是什么问题之后,然后就是专注于解决这个问题,在考虑了一上午之后还是不明白这个异步通知是怎么的接收到,然后是在一个偶然是看见了,一个提示,是说,自己的项目时候是允许这个路径的访问,因为异步通知是服务器通知,如果是你的过滤器或者是springmvc拦截器,把这个路径拦截掉之后,那么你就肯定是接收不到这个异步通知了,
这个问题真的是很简单,但是却是纠结了一上午,在过滤器中将这个异步通知路径放开之后,然后就是支付成功之后,也是执行了自己的逻辑代码,
这个就是这个异步通知的遇到的问题,
java同步和异步的区别
java同步和异步的区别如下：
一、根据情况需要专门的线程方式
如果数据将在线程间共享.例如正在写的数据以后可能被另一个线程读到,或者正在读的数据可能已经被另一个线程写过了,那么这些数据就是共享数据,必须进行同步存取.
当应用程序在对象上调用了一个需要花费很长时间来执行的方法,并且不希望让程序等待方法的返回时,就应该使用异步编程,在很多情况下采用异步途径往往更有效率.
二、应用不同：
Java同步:
基本概念:每个Object都会有1个锁.同步就是串行使用一些资源.
(说明:以下有些例子为了突出重点,省略了不必要的代码.非凡是省掉了一些成员变量,就是需要同步的对象.)
1. 多线程中对共享、可变的数据进行同步.
对于函数中的局部变量没必要进行同步.
对于不可变数据,也没必要进行同步.
多线程中访问共享可变数据才有必要.
2. 单个线程中可以使用synchronized,而且可以嵌套,但无意义.
class Test {
public static void main(String[] args) {
Test t = new Test();
synchronized(t) {
synchronized(t) {
System.out.println("ok!");
}
}
}
}
3. 对象实例的锁
class Test{
public synchronized void f1(){
//do something here
}
public void f2(){
synchronized(this){
//do something here
}
}
}
上面的f1()和f2()效果一致, synchronized取得的锁都是Test某个实列(this)的锁.
比如: Test t = new Test();
线程A调用t.f2()时, 线程B无法进入t.f1(),直到t.f2()结束.
作用: 多线程中访问Test的同一个实例的同步方法时会进行同步.
4. class的锁
class Test{
final static Object o= new Object();
public static synchronized void f1(){
//do something here
}
public static void f2(){
synchronized(Test.class){
//do something here
}
}
public static void f3(){
try {
synchronized (Class.forName("Test")) {
//do something here
}
}
catch (ClassNotFoundException ex) {
}
}
public static void g(){
synchronized(o){
//do something here
}
}
}
上面f1(),f2(),f3(),g()效果一致
f1(),f2(),f3()中synchronized取得的锁都是Test.class的锁.
g()是自己产生一个对象o,利用o的锁做同步
作用: 多线程中访问此类或此类任一个实例的同步方法时都会同步. singleton模式lazily initializing属于此类.
5. static method
class Test{
private static int v = 0;
public static void f1(){
//do something, 但函数中没用用到v
}
public synchronized static void f2(){
//do something, 函数中对v进行了读/写.
}
}
多线程中使用Test的某个实列时,
(1) f1()是线程安全的,不需要同步
(2) f2()这个静态方法中使用了函数外静态变量,所以需要同步.
Java异步:
1、 它要能适应不同类型的请求:
本节用 makeString来说明要求有返回值的请求.用displayString来说明不需要返回值的请求.
2、 要能同时并发处理多个请求,并能按一定机制调度:
本节将用一个队列来存放请求,所以只能按FIFO机制调度,你可以改用LinkedList,就可以简单实现一个优先级(优先级高的addFirst,低的addLast).
3、有能力将调用的边界从线程扩展到机器间(RMI)
4、分离过度耦合,如分离调用句柄(取货凭证)和真实数据的实现.分离调用和执行的过程,可以尽快地将调返回.
现在看具体的实现:
public interface Axman {
Result resultTest(int count,char c);
void noResultTest(String str);
}
这个接口有两个方法要实现,就是有返回值的调用resultTest和不需要返回值的调用
noResultTest, 我们把这个接口用一个代理类来实现,目的是将方法调用转化为对象,这样就可以将多个请求(多个方法调)放到一个容器中缓存起来,然后统一处理,因为 Java不支持方法指针,所以把方法调用转换为对象,然后在这个对象上统一执行它们的方法,不仅可以做到异步处理,而且可以将代表方法调用的请求对象序列化后通过网络传递到另一个机器上执行(RMI).这也是Java回调机制最有力的实现.
一个简单的例子.
如果 1: 做A
如果 2: 做B
如果 3: 做C
如果有1000个情况,你不至于用1000个case吧?以后再增加呢?
所以如果C/C++程序员,会这样实现: (c和c++定义结构不同)
type define struct MyStruct{
int mark;
(*fn) ();
} MyList;
然后你可以声明这个结构数据:
{1,A,
2,B
3,C
}
做一个循环:
for(i=0;ilength;i++) {
if(数据组[i].mark == 传入的值) (数据组[i].*fn)();
}
简单说c/c++中将要被调用的涵数可以被保存起来,然后去访问,调用,而Java中,我们无法将一个方法保存,除了直接调用,所以将要调用的方法用子类来实现,然后把这些子类实例保存起来,然后在这些子类的实现上调用方法:
interface My{
void test();
}
如何用JAVA实现异步信息处理
通常同步意味着一个任务的某个处理过程会对多个线程在用串行化处理，而异步则意味着某个处理过程可以允许多个线程同时处理。异步通常代表着更好的性能，因为它很大程度上依赖于缓冲，是典型的使用空间换时间的做法，例如在计算机当中，高速缓存作为cpu和磁盘io之间的缓冲地带协调cpu高速计算能力和磁盘的低速读写能力。
（1）：重新启动一个java程序就启动了一个进程
可以用操作系统命令行启动 Runtime.getRuntime().exec("java -classpath . XXX");
（2）：可不可以在接收消息的模块中的addtolist函数中添加一个专门的处理函数，函数执行时先向list中添加消息，然后探测当前有没有处理线程，如果没有，则启动线程。
（3）：想省点工作，可以用BlockingQueue来代替list，这样线程等待和唤醒不用写代码实现了，如果非要用list，那么就做好同步
list的小例子：
Java codeclass MessageConsumer extends Thead { private ListYourMessageType list; private boolean running = true; public MessageConsumer(ListYourMessageType list) {this.list = list;} public void run() { while (running) { YourMessageType msg = null; try { synchronized(list) { while (list.size() == 0) { list.wait(); } msg = list.remove(0); list.notiryAll(); } } catch (Exception e) { e.printStackTrace(); } if (msg == null) continue; //System.out.println(msg); //print message } }}//调用sampleclass ShareModule { ListYourMessageType list = new ArrayListYourMessageType(); ...}public class Main { public static void main(String[] args) { ShareMudule sm; //so on ... Thread t = new MessageConsumer(sm.list); t.start(); ... }}
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接口异步化的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java异步编程实战、java接口异步化的信息别忘了在本站进行查找喔。