Java Future.ensure方法代码示例

import com.twitter.util.Future; //导入方法依赖的package包/类
@Override
public <T> Future<T> apply(Function0<T> function0) {
    if (traceTaskExecution) {
        taskPendingCounter.inc();
        Stopwatch taskEnqueueStopwatch = Stopwatch.createStarted();
        Future<T> futureResult = futurePool.apply(new TimedFunction0<T>(function0));
        taskEnqueueTime.registerSuccessfulEvent(taskEnqueueStopwatch.elapsed(TimeUnit.MICROSECONDS));
        futureResult.ensure(new com.twitter.util.Function0<BoxedUnit>() {
            @Override
            public BoxedUnit apply() {
                taskPendingCounter.dec();
                return null;
            }
        });
        return futureResult;
    } else {
        return futurePool.apply(function0);
    }
}
 

import com.twitter.util.Future; //导入方法依赖的package包/类
@Benchmark
public Void ensureConstN() throws Exception {
  Future<Void> f = constVoidFuture;
  for (int i = 0; i < N.n; i++)
    f = f.ensure(ensureF);
  return Await.result(f);
}
 

import com.twitter.util.Future; //导入方法依赖的package包/类
@Benchmark
public Void ensurePromiseN() throws Exception {
  Promise<Void> p = new Promise<>();
  Future<Void> f = p;
  for (int i = 0; i < N.n; i++)
    f = f.ensure(ensureF);
  p.setValue(null);
  return Await.result(f);
}
 

import com.twitter.util.Future; //导入方法依赖的package包/类
synchronized private Future<DLSN> writeUserRecord(LogRecord record) throws IOException {
    if (null != closeFuture) {
        throw new WriteException(fullyQualifiedLogSegment, BKException.getMessage(BKException.Code.LedgerClosedException));
    }

    if (BKException.Code.OK != transmitResult.get()) {
        // Failfast if the stream already encountered error with safe retry on the client
        throw new WriteException(fullyQualifiedLogSegment, BKException.getMessage(transmitResult.get()));
    }

    if (streamEnded) {
        throw new EndOfStreamException("Writing to a stream after it has been marked as completed");
    }

    if ((record.getTransactionId() < 0) ||
        (record.getTransactionId() == DistributedLogConstants.MAX_TXID)) {
        throw new TransactionIdOutOfOrderException(record.getTransactionId());
    }

    // Inject write delay if configured to do so
    writeDelayInjector.inject();

    // Will check write rate limits and throw if exceeded.
    writeLimiter.acquire();
    pendingWrites.inc();

    // The count represents the number of user records up to the
    // current record
    // Increment the record count only when writing a user log record
    // Internally generated log records don't increment the count
    // writeInternal will always set a count regardless of whether it was
    // incremented or not.
    Future<DLSN> future = null;
    try {
        // increment the position for the record to write
        // if the record is failed to write, it would be decremented.
        positionWithinLogSegment++;
        int numRecords = 1;
        if (record.isRecordSet()) {
            numRecords = LogRecordSet.numRecords(record);
        }
        future = writeInternal(record);
        // after the record (record set) is written, the position should be
        // moved for {numRecords}, but since we already moved the record by 1
        // so advance the position for other {numRecords - 1}.
        positionWithinLogSegment += (numRecords - 1);
    } catch (IOException ex) {
        writeLimiter.release();
        pendingWrites.dec();
        positionWithinLogSegment--;
        throw ex;
    }

    // Track outstanding requests and return the future.
    return future.ensure(new Function0<BoxedUnit>() {
        public BoxedUnit apply() {
            pendingWrites.dec();
            writeLimiter.release();
            return null;
        }
    });
}