hprose.util.concurrent.Promise Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of hprose-java Show documentation
Show all versions of hprose-java Show documentation
Hprose is a High Performance Remote Object Service Engine.
It is a modern, lightweight, cross-language, cross-platform, object-oriented, high performance, remote dynamic communication middleware. It is not only easy to use, but powerful. You just need a little time to learn, then you can use it to easily construct cross language cross platform distributed application system.
Hprose supports many programming languages, for example:
* AAuto Quicker
* ActionScript
* ASP
* C++
* Dart
* Delphi/Free Pascal
* dotNET(C#, Visual Basic...)
* Golang
* Java
* JavaScript
* Node.js
* Objective-C
* Perl
* PHP
* Python
* Ruby
* ...
Through Hprose, You can conveniently and efficiently intercommunicate between those programming languages.
This project is the implementation of Hprose for Java.
/**********************************************************\
| |
| hprose |
| |
| Official WebSite: http://www.hprose.com/ |
| http://www.hprose.org/ |
| |
\**********************************************************/
/**********************************************************\
* *
* Promise.java *
* *
* Promise class for Java. *
* *
* LastModified: Sep 19, 2016 *
* Author: Ma Bingyao *
* *
\**********************************************************/
package hprose.util.concurrent;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
public final class Promise implements Resolver, Rejector, Thenable {
private static volatile ScheduledExecutorService timer = Executors.newSingleThreadScheduledExecutor();
static {
Threads.registerShutdownHandler(new Runnable() {
public void run() {
ScheduledExecutorService t = timer;
timer = Executors.newSingleThreadScheduledExecutor();
t.shutdownNow();
}
});
}
private final LinkedList> subscribers = new LinkedList>();
private volatile AtomicReference state = new AtomicReference(State.PENDING);
private volatile V value;
private volatile Throwable reason;
public Promise() {}
public Promise(final Call computation) {
timer.execute(new Runnable() {
public void run() {
try {
Promise.this.resolve(computation.call());
}
catch (Throwable e) {
Promise.this.reject(e);
}
}
});
}
public Promise(final AsyncCall computation) {
timer.execute(new Runnable() {
public void run() {
try {
Promise.this.resolve(computation.call());
}
catch (Throwable e) {
Promise.this.reject(e);
}
}
});
}
public Promise(Executor executor) {
executor.exec((Resolver)this, (Rejector)this);
}
public final static Promise value(T value) {
Promise promise = new Promise();
promise.resolve(value);
return promise;
}
public final static Promise value(Promise value) {
Promise promise = new Promise();
promise.resolve(value);
return promise;
}
public final static Promise value(Thenable value) {
Promise promise = new Promise();
promise.resolve(value);
return promise;
}
public final static Promise error(Throwable reason) {
Promise promise = new Promise();
promise.reject(reason);
return promise;
}
public final static Promise delayed(long duration, TimeUnit timeunit, final Call computation) {
final Promise promise = new Promise();
timer.schedule(new Runnable() {
public void run() {
try {
promise.resolve(computation.call());
}
catch (Throwable e) {
promise.reject(e);
}
}
}, duration, timeunit);
return promise;
}
public final static Promise delayed(long duration, TimeUnit timeunit, final AsyncCall computation) {
final Promise promise = new Promise();
timer.schedule(new Runnable() {
public void run() {
try {
promise.resolve(computation.call());
}
catch (Throwable e) {
promise.reject(e);
}
}
}, duration, timeunit);
return promise;
}
public final static Promise delayed(long duration, TimeUnit timeunit, final T value) {
final Promise promise = new Promise();
timer.schedule(new Runnable() {
public void run() {
promise.resolve(value);
}
}, duration, timeunit);
return promise;
}
public final static Promise delayed(long duration, TimeUnit timeunit, final Promise value) {
final Promise promise = new Promise();
timer.schedule(new Runnable() {
public void run() {
promise.resolve(value);
}
}, duration, timeunit);
return promise;
}
public final static Promise delayed(long duration, Call computation) {
return delayed(duration, TimeUnit.MILLISECONDS, computation);
}
public final static Promise delayed(long duration, AsyncCall computation) {
return delayed(duration, TimeUnit.MILLISECONDS, computation);
}
public final static Promise delayed(long duration, T value) {
return delayed(duration, TimeUnit.MILLISECONDS, value);
}
public final static Promise delayed(long duration, Promise value) {
return delayed(duration, TimeUnit.MILLISECONDS, value);
}
public final static Promise sync(Call computation) {
try {
return value(computation.call());
}
catch (Throwable e) {
return error(e);
}
}
public final static Promise sync(AsyncCall computation) {
try {
return value(computation.call());
}
catch (Throwable e) {
return error(e);
}
}
public final static boolean isThenable(Object value) {
return value instanceof Thenable;
}
public final static boolean isPromise(Object value) {
return value instanceof Promise;
}
public final static Promise toPromise(Object value) {
return isPromise(value) ? (Promise)value : value(value);
}
@SuppressWarnings("unchecked")
private static void allHandler(final Promise promise, final AtomicInteger count, final T[] result, Object element, final int i) {
((Promise)toPromise(element)).then(
new Action() {
public void call(T value) throws Throwable {
result[i] = value;
if (count.decrementAndGet() == 0) {
promise.resolve(result);
}
}
},
new Action() {
public void call(Throwable e) throws Throwable {
promise.reject(e);
}
}
);
}
@SuppressWarnings("unchecked")
public final static Promise all(Object[] array, Class type) {
if (array == null) return value((T[])null);
int n = array.length;
T[] result = (type == Object.class) ?
(T[])(new Object[n]) :
(T[])Array.newInstance(type, n);
if (n == 0) return value(result);
AtomicInteger count = new AtomicInteger(n);
Promise promise = new Promise();
for (int i = 0; i < n; ++i) {
allHandler(promise, count, result, array[i], i);
}
return promise;
}
public final static Promise