Java ListenableFuture.get方法代码示例

import org.threadly.concurrent.future.ListenableFuture; //导入方法依赖的package包/类
@Test
public void watchAlreadyDoneFutureWithFailureTest() throws InterruptedException {
  final Throwable rootCause = new Exception();
  ListenableFuture<Object> lfResult = poller.watch(new AlreadyDoneFuture() {
    @Override
    public Object get() throws ExecutionException {
      throw new ExecutionException(rootCause);
    }

    @Override
    public Object get(long timeout, TimeUnit unit) throws ExecutionException {
      throw new ExecutionException(rootCause);
    }
  });
  
  assertTrue(lfResult.isDone());
  try {
    lfResult.get();
    fail("Exception should have thrown");
  } catch (ExecutionException e) {
    assertTrue(e.getCause() == rootCause);
  }
}
 

import org.threadly.concurrent.future.ListenableFuture; //导入方法依赖的package包/类
@Test
public void watchIncompleteFutureWithFailureTest() throws InterruptedException {
  poller = new Poller(scheduler, POLL_INTERVAL, POLL_INTERVAL * 2);  // must have timeout to avoid just casting SLF
  Throwable rootCause = new Exception();
  SettableListenableFuture<Object> slf = new SettableListenableFuture<>();
  ListenableFuture<Object> lfResult = poller.watch(slf);
  
  assertFalse(lfResult.isDone());
  
  slf.setFailure(rootCause);
  assertEquals(1, scheduler.advance(POLL_INTERVAL));
  
  assertTrue(lfResult.isDone());
  try {
    lfResult.get();
    fail("Exception should have thrown");
  } catch (ExecutionException e) {
    assertTrue(e.getCause() == rootCause);
  }
}
 

import org.threadly.concurrent.future.ListenableFuture; //导入方法依赖的package包/类
@Test
public void submitRunnableExceptionTest() throws InterruptedException {
  SubmitterExecutorFactory factory = getSubmitterExecutorFactory();
  try {
    SubmitterExecutor executor = factory.makeSubmitterExecutor(TEST_QTY, false);
    
    RuntimeException failure = new SuppressedStackRuntimeException();
    TestRuntimeFailureRunnable tr = new TestRuntimeFailureRunnable(failure);
    ListenableFuture<?> future = executor.submit(tr);
    // no exception should propagate
    
    try {
      future.get();
      fail("Exception should have thrown");
    } catch (ExecutionException e) {
      assertTrue(e.getCause() == failure);
    }
  } finally {
    factory.shutdown();
  }
}
 

import org.threadly.concurrent.future.ListenableFuture; //导入方法依赖的package包/类
@Test
public void submitRunnableWithResultExceptionTest() throws InterruptedException {
  SubmitterExecutorFactory factory = getSubmitterExecutorFactory();
  try {
    SubmitterExecutor executor = factory.makeSubmitterExecutor(TEST_QTY, false);
    
    RuntimeException failure = new SuppressedStackRuntimeException();
    TestRuntimeFailureRunnable tr = new TestRuntimeFailureRunnable(failure);
    ListenableFuture<?> future = executor.submit(tr, new Object());
    // no exception should propagate
    
    tr.blockTillFinished();
    assertTrue(future.isDone());
    try {
      future.get();
      fail("Exception should have thrown");
    } catch (ExecutionException e) {
      assertTrue(e.getCause() == failure);
    }
  } finally {
    factory.shutdown();
  }
}
 

import org.threadly.concurrent.future.ListenableFuture; //导入方法依赖的package包/类
@Test
public void submitCallableExceptionTest() throws InterruptedException {
  SubmitterExecutorFactory factory = getSubmitterExecutorFactory();
  try {
    SubmitterExecutor executor = factory.makeSubmitterExecutor(TEST_QTY, false);
    
    final RuntimeException failure = new SuppressedStackRuntimeException();
    ListenableFuture<?> future = executor.submit(new Callable<Void>() {
      @Override
      public Void call() throws Exception {
        throw failure;
      }
    });
    // no exception should propagate
    
    try {
      future.get();
      fail("Exception should have thrown");
    } catch (ExecutionException e) {
      assertTrue(e.getCause() == failure);
    }
  } finally {
    factory.shutdown();
  }
}
 

import org.threadly.concurrent.future.ListenableFuture; //导入方法依赖的package包/类
@Test
public void startWitExecutorAndTimeoutTest() throws InterruptedException, ExecutionException, TimeoutException {
  StrictPriorityScheduler ps = new StrictPriorityScheduler(2);
  try {
    long start = Clock.accurateForwardProgressingMillis();
    ListenableFuture<String> lf = profiler.start(ps, DELAY_TIME);
    String result = lf.get(10 * 1000, TimeUnit.MILLISECONDS);
    long end = Clock.accurateForwardProgressingMillis();

    // profiler should be stopped now
    assertFalse(profiler.isRunning());
    assertTrue(end - start >= DELAY_TIME);
    assertNotNull(result);
  } finally {
    ps.shutdownNow();
  }
}
 

import org.threadly.concurrent.future.ListenableFuture; //导入方法依赖的package包/类
@Test
public void limitTest() throws InterruptedException, ExecutionException {
  int rateLimit = 100;
  final AtomicInteger ranPermits = new AtomicInteger();
  PriorityScheduler pse = new StrictPriorityScheduler(32);
  try {
    RateLimiterExecutor rls = new RateLimiterExecutor(pse, rateLimit);
    ListenableFuture<?> lastFuture = null;
    double startTime = Clock.accurateForwardProgressingMillis();
    boolean flip = true;
    for (int i = 0; i < TEST_QTY * 2; i++) {
      final int permit = 5;
      if (flip) {
        lastFuture = rls.submit(permit, new Runnable() {
          @Override
          public void run() {
            ranPermits.addAndGet(permit);
          }
        });
        flip = false;
      } else {
        lastFuture = rls.submit(permit, new Callable<Void>() {
          @Override
          public Void call() {
            ranPermits.addAndGet(permit);
            return null;
          }
        });
        flip = true;
      }
    }
    lastFuture.get();
    long endTime = Clock.accurateForwardProgressingMillis();
    double actualLimit = ranPermits.get() / ((endTime - startTime) / 1000);
    
    assertEquals(rateLimit, actualLimit, SLOW_MACHINE ? 75 : 50);
  } finally {
    pse.shutdownNow();
  }
}
 

import org.threadly.concurrent.future.ListenableFuture; //导入方法依赖的package包/类
@Test
public void startWithTimeoutTest() throws InterruptedException, ExecutionException, TimeoutException {
  long start = Clock.accurateForwardProgressingMillis();
  ListenableFuture<String> lf = profiler.start(DELAY_TIME);
  String result = lf.get(DELAY_TIME + (10 * 1000), TimeUnit.MILLISECONDS);
  long end = Clock.accurateForwardProgressingMillis();

  // profiler should be stopped now
  assertFalse(profiler.isRunning());
  assertTrue(end - start >= DELAY_TIME);
  assertNotNull(result);
}
 

import org.threadly.concurrent.future.ListenableFuture; //导入方法依赖的package包/类
@Test
public void limitTest() throws InterruptedException, ExecutionException {
  Object key = new Object();
  int rateLimit = 100;
  final AtomicInteger ranPermits = new AtomicInteger();
  PriorityScheduler pse = new StrictPriorityScheduler(32);
  try {
    KeyedRateLimiterExecutor krls = new KeyedRateLimiterExecutor(pse, rateLimit);
    ListenableFuture<?> lastFuture = null;
    double startTime = Clock.accurateForwardProgressingMillis();
    boolean flip = true;
    for (int i = 0; i < TEST_QTY * 2; i++) {
      final int permit = 5;
      if (flip) {
        lastFuture = krls.submit(permit, key, new Runnable() {
          @Override
          public void run() {
            ranPermits.addAndGet(permit);
          }
        });
        flip = false;
      } else {
        lastFuture = krls.submit(permit, key, new Callable<Void>() {
          @Override
          public Void call() {
            ranPermits.addAndGet(permit);
            return null;
          }
        });
        flip = true;
      }
    }
    lastFuture.get();
    long endTime = Clock.accurateForwardProgressingMillis();
    double actualLimit = ranPermits.get() / ((endTime - startTime) / 1000);
    
    assertEquals(rateLimit, actualLimit, SLOW_MACHINE ? 75 : 50);
  } finally {
    pse.shutdownNow();
  }
}
 

import org.threadly.concurrent.future.ListenableFuture; //导入方法依赖的package包/类
@SuppressWarnings("javadoc")
public static void main(final String args[]) throws InterruptedException {
  if (args.length == 0) {
    System.err.println("No number to test provided");
    System.err.println("Usage: java -cp threadly_examples.jar " + 
                         NextPrime.class.getName() + " [number to start search from]...");
    System.exit(1);
  }
  
  final int processingThreads = Runtime.getRuntime().availableProcessors() * 2;
  int threadPoolSize = processingThreads + args.length - 1;
  final PriorityScheduler executor = new PriorityScheduler(threadPoolSize, true);
  executor.prestartAllThreads();
  
  Deque<ListenableFuture<PrimeResult>> futures = new ArrayDeque<ListenableFuture<PrimeResult>>(processingThreads * 2);
  
  int value = Integer.parseInt(args[0]) + 1;
  while (true) {
    final int f_i = value++;
    futures.add(executor.submit(new Callable<PrimeResult>() {
      @Override
      public PrimeResult call() throws InterruptedException {
        return testNumber(executor, processingThreads, f_i);
      }
    }));
    
    boolean firstRun = true;
    while (firstRun || futures.size() > processingThreads * 2) {
      firstRun = false;
      Iterator<ListenableFuture<PrimeResult>> it = futures.iterator();
      while (it.hasNext()) {
        ListenableFuture<PrimeResult> f = it.next();
        if (f.isDone()) {
          try {
            PrimeResult result = f.get();
            if (result.isPrime) {
              System.out.println("The next prime number is: " + result.testNumber);
              System.exit(0);
            } else {
              it.remove();
            }
          } catch (ExecutionException e) {
            throw ExceptionUtils.makeRuntime(e.getCause());
          }
        } else {
          break;
        }
      }
      
      Thread.sleep(10);
    }
  }
}