import org.osgi.util.promise.Deferred; //导入依赖的package包/类
@Override
public Promise<Void> restart() {

    Deferred<Void> future = new Deferred<>();
    Thread restartThread = new Thread("Restart-Server-Thread") {
        @Override
        public void run() {
            Server.inMaintenance = true;
            try {
                log.info("Restarting server.");
                boolean successStarted = startNewServer();
                if (!successStarted) {
                    throw new Exception("Fail to start new server process.");
                }
                log.info("Restart server (pid:" + ServerUtil.getCurrentPid() + ")");

                future.resolve(null);
            } catch (Exception ex) {
                future.fail(ex);
            }
        }
    };
    restartThread.start();
    return future.getPromise();
}
 

import org.osgi.util.promise.Deferred; //导入依赖的package包/类
@Override
public Promise<String> callAsyncPromise(final int delay) {
    final Deferred<String> deferred = new Deferred<String>();
    new Thread(new Runnable() {
        
        @Override
        public void run() {
            if (delay == -1) {
                deferred.fail(new ExpectedTestException());
                return;
            }
            sleep(delay);
            deferred.resolve("Finished");
        }
    }).start();
    
    return deferred.getPromise();
}
 

import org.osgi.util.promise.Deferred; //导入依赖的package包/类
@Override
public Promise<Long> getLongResult() {
    Deferred<Long> d = new Deferred<>();

    Promise<Long> promise = superSlowService.compute();
    promise.onResolve(() -> {
        new Thread(new Runnable() {

            @Override
            public void run() {
                d.resolveWith(promise);
            }
        }).start();
    });
    Promise<Long> promise2 = d.getPromise();

    return promise2;
}
 

import org.osgi.util.promise.Deferred; //导入依赖的package包/类
private Promise<NeuralNetworkSequenceResult> forward(int index, UUID[] inputIds, UUID[] outputIds, List<Tensor>[] inputs, String... tags){
	int sequenceLength = inputs[0].size();

	storeSequenceMemories(index);

	return forward(inputIds, outputIds, getSequenceInputs(index, inputs), tags).then(p -> {
		// store output
		storeSequenceOutputs(index, p.getValue().tensors);

		// increment counter
		int next = index + 1;
		
		// check if we are done
		if(next == sequenceLength){
			Deferred<NeuralNetworkSequenceResult> d = new Deferred<>();
			d.resolve(new NeuralNetworkSequenceResult(sequenceOutputs, tags));
			return d.getPromise();
		} else {
			return forward(next, inputIds, outputIds, inputs, tags);
		}
	});
}
 

import org.osgi.util.promise.Deferred; //导入依赖的package包/类
@Override
public Promise<NeuralNetwork> getNeuralNetwork(NeuralNetworkInstanceDTO nni) {
	Deferred<NeuralNetwork> result = new Deferred<>();
	
	NeuralNetwork nn = nnServices.get(nni.id);
	if(nn!=null){
		result.resolve(nn);
		return result.getPromise();
	}
	
	ToWatch w = new ToWatch();
	w.nni = nni;
	w.deferred = result; 
	toWatchFor.put(nni.id, w);
	
	createNeuralNetwork(nni.id);
	
	return result.getPromise();
}
 

import org.osgi.util.promise.Deferred; //导入依赖的package包/类
public AsyncResponseFuture(ClassLoader loader, Method method, SerializationStrategy serializationStrategy, DispatchQueue queue) {
    this.loader = loader;
    this.method = method;
    this.serializationStrategy = serializationStrategy;
    this.queue = queue;
    this.deferred = new Deferred<>();
}
 

import org.osgi.util.promise.Deferred; //导入依赖的package包/类
@Override
public Promise<String> exceptionPromise() throws IOException {
    final Deferred<String> deferred = new Deferred<String>();
    new Thread(() -> {
        sleep(500);
        deferred.fail(new IOException("test"));
    }).start();
     return deferred.getPromise();
}
 

import org.osgi.util.promise.Deferred; //导入依赖的package包/类
private Object createPromiseResult(final Method method, final Object[] args) {
    final Deferred<Object> deferred = new Deferred<Object>();
    new Thread(new Runnable() {
        
        @Override
        public void run() {
            try {
                deferred.resolve(handleSyncCall(method, args));
            } catch (Throwable e) {
                deferred.fail(e);
            }
        }
    }).start();
    return deferred.getPromise();
}
 

import org.osgi.util.promise.Deferred; //导入依赖的package包/类
@Override
@Timed
public Promise<Long> compute() {
    Deferred<Long> deferred = new Deferred<>();
    executor.submit(() -> {
        Uninterruptibles.sleepUninterruptibly(3, TimeUnit.SECONDS);
        deferred.resolve(42L);
    });
    return deferred.getPromise();
}
 

import org.osgi.util.promise.Deferred; //导入依赖的package包/类
private synchronized void trigger(String rfid){
	// first keep the old deferred we have to resolve
	Deferred<String> toResolve = nextRFID;

	// create new deferred for next, since we will call 
	// a new nextRFID() when the previous is resolved
	nextRFID = new Deferred<String>();
	
	// resolve previous
	toResolve.resolve(rfid);
	// set lastRFID
	this.lastRFID = rfid;
}
 

import org.osgi.util.promise.Deferred; //导入依赖的package包/类
@Override
public Promise<String> helloPromise() {
    final Deferred<String> deferred = new Deferred<String>();
    new Thread(() -> deferred.resolve("Hello")).start();
    return deferred.getPromise();
}
 

import org.osgi.util.promise.Deferred; //导入依赖的package包/类
private synchronized void trigger(String trainId, String segment) {
    // info("trigger: trainId={} segment={}", trainId, segment);
    Deferred<String> currentLocation = nextLocation;
    nextLocation = new Deferred<String>();
    currentLocation.resolve(trainId + ":" + segment);
}
 

import org.osgi.util.promise.Deferred; //导入依赖的package包/类
private synchronized void trigger(String trainId, String segment) {
    Deferred<String> currentLocation = nextLocation;
    nextLocation = new Deferred<String>();
    currentLocation.resolve(trainId + ":" + segment);
}
 

import org.osgi.util.promise.Deferred; //导入依赖的package包/类
private synchronized void trigger(String rfid) {
	Deferred<String> toResolve = nextRFID;
	nextRFID = new Deferred<String>();
	toResolve.resolve(rfid);
	this.lastRFID = rfid;
}