“JVM flow control in bytecode”与“Vertx: Future异步操作设计”:页面之间的差异

来自WHY42
(页面间差异)
 
 
第1行: 第1行:
=Future相关操作的设计=
== AsyncResult ==
AsyncResult表示一个异步操作的结果,这个结果要么是成功的,要么是失败的。
<syntaxhighlight lang="java">
interface AsyncResult<T> {
    /* 获取异步结果,或者失败原因。倘若失败,那么结果为null */
    T getResult();
    Throwable cause();
    boolean succeeded();
    boolean failed();


= Branch =
    /* 对结果进行转换。如果成功,那么可以将成功的结果转换为另一种形式;否则可以得到一个替代的结果。*/
 
    <V> AsyncResult<V> map(Function<T, V> mapper);
<syntaxhighlight lang="java">
    <V> AsyncResult<V> map(V value);
public int abs(int i) {
    <V> AsyncResult<V> mapEmpty();
     if(i < 0)
    AsyncResult<T> otherwise(T value);
        return -i;
     AsyncResult<T> otherwise(Function<Throwable, T> mapper);
     return i;
     AsyncResult<T> otherwiseEmpty();
}
}
</syntaxhighlight>
</syntaxhighlight>


<syntaxhighlight lang="lisp">
==Future==
  public int abs(int);
Future表示一个尚未完成的异步操作,并继承自AsyncResult
    descriptor: (I)I
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=1, locals=2, args_size=2
        0: iload_1
        1: ifge          7
        4: iload_1
        5: ineg
        6: ireturn
        7: iload_1
        8: ireturn
      LineNumberTable:
        line 3: 0
        line 4: 4
        line 5: 7
      StackMapTable: number_of_entries = 1
        frame_type = 7 /* same
</syntaxhighlight>
 
<syntaxhighlight lang="java">
<syntaxhighlight lang="java">
public int compareWith2(int i) {
interface Future<T>
     if(i < 2)
    extends AsyncResult<T> {
        return -1;
    boolean isComplete();
     else if(i == 2)
    Future<T> onComplete(Handler<AsyncResult<T>> handler);
        return 0;
    Future<T> onSuccess(Handler<T> handler);
     else
    Future<T> onFailure(Handler<Throwable> handler);
        return 1;
     <V> Future<V> compose(Function<T, Future<V>> mapper);
    <V> Future<V> compose(Function<T, Future<V>> successMapper,
                      Function<Throwable, Future<V>> failureMapper);
     Future<T> recover(Function<Throwable, Future<T>> mapper);
    <V> Future<V> transform(Function<AsyncResult<T>, Future<V>> mapper);
     <V> Future<T> eventually(Function<Void, Future<V>> mapper);
    CompletionStage<T> toCompletionState();
}
}
</syntaxhighlight>
</syntaxhighlight>


<syntaxhighlight lang="lisp">
[[Category:Vert.x]]
  public int compareWith2(int);
    descriptor: (I)I
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=2, args_size=2
        0: iload_1
        1: iconst_2
        2: if_icmpge    7
        5: iconst_m1
        6: ireturn
        7: iload_1
        8: iconst_2
        9: if_icmpne    14
        12: iconst_0
        13: ireturn
        14: iconst_1
        15: ireturn
      LineNumberTable:
        line 8: 0
        line 9: 5
        line 10: 7
        line 11: 12
        line 13: 14
      StackMapTable: number_of_entries = 2
        frame_type = 7 /* same */
        frame_type = 6 /* same */
}
</syntaxhighlight>
[[Category:JVM]]

2021年7月25日 (日) 08:21的版本

Future相关操作的设计

AsyncResult

AsyncResult表示一个异步操作的结果,这个结果要么是成功的,要么是失败的。

interface AsyncResult<T> {
    /* 获取异步结果,或者失败原因。倘若失败,那么结果为null */
    T getResult();
    Throwable cause();
    boolean succeeded();
    boolean failed();

    /* 对结果进行转换。如果成功,那么可以将成功的结果转换为另一种形式;否则可以得到一个替代的结果。*/
    <V> AsyncResult<V> map(Function<T, V> mapper);
    <V> AsyncResult<V> map(V value);
    <V> AsyncResult<V> mapEmpty();
    AsyncResult<T> otherwise(T value);
    AsyncResult<T> otherwise(Function<Throwable, T> mapper);
    AsyncResult<T> otherwiseEmpty();
}

Future

Future表示一个尚未完成的异步操作,并继承自AsyncResult

interface Future<T>
    extends AsyncResult<T> {
    boolean isComplete();
    Future<T> onComplete(Handler<AsyncResult<T>> handler);
    Future<T> onSuccess(Handler<T> handler);
    Future<T> onFailure(Handler<Throwable> handler);
    <V> Future<V> compose(Function<T, Future<V>> mapper);
    <V> Future<V> compose(Function<T, Future<V>> successMapper, 
                      Function<Throwable, Future<V>> failureMapper);
    Future<T> recover(Function<Throwable, Future<T>> mapper);
    <V> Future<V> transform(Function<AsyncResult<T>, Future<V>> mapper);
    <V> Future<T> eventually(Function<Void, Future<V>> mapper);
    CompletionStage<T> toCompletionState();
}