@Test(groups = "standalone", enabled = false) public void testProxyActivationProperty() throws IOException, ExecutionException, TimeoutException, InterruptedException { // FIXME not threadsafe! Properties originalProps = new Properties(); originalProps.putAll(System.getProperties()); System.setProperty(ProxyUtils.PROXY_HOST, "127.0.0.1"); System.setProperty(ProxyUtils.PROXY_PORT, String.valueOf(port1)); System.setProperty(ProxyUtils.PROXY_NONPROXYHOSTS, "localhost"); System.setProperty( AsyncHttpClientConfigDefaults.ASYNC_CLIENT_CONFIG_ROOT + "useProxyProperties", "true"); AsyncHttpClientConfigHelper.reloadProperties(); try (AsyncHttpClient client = asyncHttpClient()) { String proxifiedTarget = "http://127.0.0.1:1234/"; Future<Response> f = client.prepareGet(proxifiedTarget).execute(); Response resp = f.get(3, TimeUnit.SECONDS); assertNotNull(resp); assertEquals(resp.getStatusCode(), HttpServletResponse.SC_OK); assertEquals(resp.getHeader("target"), "/"); String nonProxifiedTarget = "http://localhost:1234/"; f = client.prepareGet(nonProxifiedTarget).execute(); try { resp = f.get(3, TimeUnit.SECONDS); fail("should not be able to connect"); } catch (ExecutionException e) { // ok, no proxy used } } finally { System.setProperties(originalProps); } }
@Test public void testCreateNewIfExpired() throws Exception { final LocalConnFactory connFactory = Mockito.mock(LocalConnFactory.class); final HttpConnection conn1 = Mockito.mock(HttpConnection.class); Mockito.when(conn1.isOpen()).thenReturn(true); Mockito.when(connFactory.create(Mockito.eq("somehost"))).thenReturn(conn1); final LocalConnPool pool = new LocalConnPool(connFactory, 2, 2); final Future<LocalPoolEntry> future1 = pool.lease("somehost", null); final LocalPoolEntry entry1 = future1.get(1, TimeUnit.SECONDS); Assert.assertNotNull(entry1); Mockito.verify(connFactory, Mockito.times(1)).create(Mockito.eq("somehost")); entry1.updateExpiry(1, TimeUnit.MILLISECONDS); pool.release(entry1, true); Thread.sleep(200L); final Future<LocalPoolEntry> future2 = pool.lease("somehost", null); final LocalPoolEntry entry2 = future2.get(1, TimeUnit.SECONDS); Assert.assertNotNull(entry2); Mockito.verify(connFactory, Mockito.times(2)).create(Mockito.eq("somehost")); final PoolStats totals = pool.getTotalStats(); Assert.assertEquals(0, totals.getAvailable()); Assert.assertEquals(1, totals.getLeased()); Assert.assertEquals(Collections.singleton("somehost"), pool.getRoutes()); final PoolStats stats = pool.getStats("somehost"); Assert.assertEquals(0, stats.getAvailable()); Assert.assertEquals(1, stats.getLeased()); }
public void submit() { dbTextArea.clear(); LocalDate from = fromDate.getValue(), to = toDate.getValue(); Future<String[]> fwarNames = db.getWarNamesByDate(from, to); HashSet<Future<long[]>> fstats = new HashSet<Future<long[]>>(); try { String[] warNames = fwarNames.get(); for (String war : warNames) { fstats.add(db.getWarStats(war)); } int i = 0; for (Future<long[]> fWarStats : fstats) { long[] stats = fWarStats.get(); dbTextArea.appendText("\t" + warNames[i++] + " Statistics\n"); dbTextArea.appendText("=========================================\n"); dbTextArea.appendText('\t' + stats[0] == 0 ? "War is still running" : "\tWar has ended\n"); dbTextArea.appendText("\tNum of launch missiles: " + stats[1] + "\n"); dbTextArea.appendText("\tNum of intercept missiles: " + stats[2] + "\n"); dbTextArea.appendText("\tNum of hit target missiles: " + stats[3] + "\n"); dbTextArea.appendText("\tNum of launchers destroyed: " + stats[4] + "\n"); dbTextArea.appendText("\ttotal damage: " + stats[5] + "\n"); dbTextArea.appendText("==========================================\n"); } } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); } }
private int[] computeClusterNumberRange(int min, int max, int hop, Optimizer optimizer) throws ExecutionException, InterruptedException { ExecutorService executor; if (parallelWorkers > 1) { executor = Executors.newFixedThreadPool(2); } else { executor = Executors.newFixedThreadPool(1); } ConcurrentMap<Integer, Double> sharedScores = new ConcurrentHashMap<>(); SearchSpaceBoundaryFinder_old upperBoundFinder = new SearchSpaceUpperBoundaryFinder_old(min, max, hop, optimizer, sharedScores); Future<Integer> futureUpperBound = executor.submit(upperBoundFinder); SearchSpaceBoundaryFinder_old lowerBoundFinder = new SearchSpaceLowerBoundaryFinder_old(min, max, hop, optimizer, sharedScores); Future<Integer> futureLowerBound = executor.submit(lowerBoundFinder); executor.shutdown(); int[] r = new int[2]; Integer realMin = futureLowerBound.get(); Integer realMax = futureUpperBound.get(); r[0] = realMin == null ? -1 : realMin; r[1] = realMax == null ? -1 : realMax; scores.putAll(lowerBoundFinder.getSplitsAndScores()); // scores.putAll(upperBoundFinder.getSplitsAndScores()); return r; }
private Object invokeOperation(Data key, MapOperation operation) { int partitionId = getNodeEngine().getPartitionService().getPartitionId(key); operation.setThreadId(ThreadUtil.getThreadId()); try { Object result; if (statisticsEnabled) { long time = System.currentTimeMillis(); Future future = operationService .createInvocationBuilder(SERVICE_NAME, operation, partitionId) .setResultDeserialized(false) .invoke(); result = future.get(); mapServiceContext.incrementOperationStats(time, localMapStats, name, operation); } else { Future future = operationService .createInvocationBuilder(SERVICE_NAME, operation, partitionId) .setResultDeserialized(false) .invoke(); result = future.get(); } return result; } catch (Throwable t) { throw rethrow(t); } }
private Permit getEither(Future<Permit> f1, Future<Permit> f2) throws Exception { try { return f1.get(10, TimeUnit.MILLISECONDS); } catch (TimeoutException e) { return f2.get(10, TimeUnit.MILLISECONDS); } }
@Override protected void setUp() throws Exception { super.setUp(); final PipedInputStream p1i = new PipedInputStream(); final PipedInputStream p2i = new PipedInputStream(); final PipedOutputStream p1o = new PipedOutputStream(p1i); final PipedOutputStream p2o = new PipedOutputStream(p2i); Future<Channel> f1 = executors.submit( new Callable<Channel>() { public Channel call() throws Exception { return new Channel("This side of the channel", executors, p1i, p2o); } }); Future<Channel> f2 = executors.submit( new Callable<Channel>() { public Channel call() throws Exception { return new Channel("The other side of the channel", executors, p2i, p1o); } }); french = f1.get(); british = f2.get(); }
@Test @PresetData(PresetData.DataSet.NO_ANONYMOUS_READACCESS) public void testRunnableAgainstAllContexts() throws Exception { Runnable r = new Runnable() { public void run() { runnableThreadContext = SecurityContextHolder.getContext(); } }; SecurityContextHolder.setContext(systemContext); Future systemResult = wrappedService.submit(r); // Assert the runnable completed successfully assertNull(systemResult.get()); // Assert the context inside the runnable thread was set to ACL.SYSTEM assertEquals(systemContext, runnableThreadContext); SecurityContextHolder.setContext(userContext); Future userResult = wrappedService.submit(r); // Assert the runnable completed successfully assertNull(userResult.get()); // Assert the context inside the runnable thread was set to the user's context assertEquals(userContext, runnableThreadContext); SecurityContextHolder.setContext(nullContext); Future nullResult = wrappedService.submit(r); // Assert the runnable completed successfully assertNull(nullResult.get()); // Assert the context inside the runnable thread was set to the null context assertEquals(nullContext, runnableThreadContext); }
@Test public void testEvictUpdateExpiration() throws Exception { CyclicBarrier loadBarrier = new CyclicBarrier(2); CountDownLatch preFlushLatch = new CountDownLatch(1); CountDownLatch postEvictLatch = new CountDownLatch(1); CountDownLatch flushLatch = new CountDownLatch(1); CountDownLatch commitLatch = new CountDownLatch(1); Future<Boolean> first = evictWait(itemId, loadBarrier, null, postEvictLatch); Future<Boolean> second = updateFlushWait(itemId, loadBarrier, preFlushLatch, flushLatch, commitLatch); awaitOrThrow(postEvictLatch); Map contents = Caches.entrySet(entityCache).toMap(); assertEquals(Collections.EMPTY_MAP, contents); assertNull(contents.get(itemId)); preFlushLatch.countDown(); awaitOrThrow(flushLatch); contents = Caches.entrySet(entityCache).toMap(); assertEquals(1, contents.size()); assertEquals(FutureUpdate.class, contents.get(itemId).getClass()); commitLatch.countDown(); first.get(WAIT_TIMEOUT, TimeUnit.SECONDS); second.get(WAIT_TIMEOUT, TimeUnit.SECONDS); contents = Caches.entrySet(entityCache).toMap(); assertEquals(1, contents.size()); Object value = contents.get(itemId); assertNotNull(value); assertEquals(StandardCacheEntryImpl.class, value.getClass()); TIME_SERVICE.advance(timeout + 1); assertEquals(value, entityCache.get(itemId)); }
/** * When a build is marked as NOT_BUILD And more builds are started And there are no changes Then * all following builds should also be marked NOT_BUILD */ public void testShouldMarkBuildsAsNotBuilt() throws Exception { setup(); File dir = createTempDirectory(); MercurialBridge plugin = new MercurialBridge(false, "test", "default"); plugin.setWorkingDirectory(new FilePath(dir)); hg(dir, "init"); shell(dir, "touch", "foo"); hg(dir, "add", "foo"); hg(dir, "commit", "-m", "\"added foo\""); // String rev = hg(dir,"tip","--template","{node}").toString(); hg(dir, "branch", "test"); shell(dir, "touch", "bar"); hg(dir, "add", "bar"); hg(dir, "commit", "-m", "\"added bar\""); MercurialSCM scm = new MercurialSCM(null, dir.getAbsolutePath(), "test", null, null, null, true); FreeStyleProject project = Hudson.getInstance().createProject(FreeStyleProject.class, "testproject"); project.setScm(scm); project.getBuildWrappersList().add(new PretestedIntegrationBuildWrapper(plugin)); Future<FreeStyleBuild> f = project.scheduleBuild2(0); FreeStyleBuild build = f.get(); assertEquals(Result.SUCCESS, build.getResult()); f = project.scheduleBuild2(0); build = f.get(); assertEquals(Result.NOT_BUILT, build.getResult()); f = project.scheduleBuild2(0); build = f.get(); assertEquals(Result.NOT_BUILT, build.getResult()); cleanup(dir); }
@Test public void testFutureUpdateExpiration() throws Exception { CyclicBarrier loadBarrier = new CyclicBarrier(2); CountDownLatch flushLatch = new CountDownLatch(2); CountDownLatch commitLatch = new CountDownLatch(1); Future<Boolean> first = updateFlushWait(itemId, loadBarrier, null, flushLatch, commitLatch); Future<Boolean> second = updateFlushWait(itemId, loadBarrier, null, flushLatch, commitLatch); awaitOrThrow(flushLatch); Map contents = Caches.entrySet(entityCache).toMap(); assertEquals(1, contents.size()); assertEquals(FutureUpdate.class, contents.get(itemId).getClass()); commitLatch.countDown(); first.get(WAIT_TIMEOUT, TimeUnit.SECONDS); second.get(WAIT_TIMEOUT, TimeUnit.SECONDS); // since we had two concurrent updates, the result should be invalid contents = Caches.entrySet(entityCache).toMap(); assertEquals(1, contents.size()); Object value = contents.get(itemId); if (value instanceof FutureUpdate) { // DB did not blocked two concurrent updates TIME_SERVICE.advance(timeout + 1); assertNull(entityCache.get(itemId)); contents = Caches.entrySet(entityCache).toMap(); assertEquals(Collections.EMPTY_MAP, contents); } else { // DB left only one update to proceed, and the entry should not be expired assertNotNull(value); assertEquals(StandardCacheEntryImpl.class, value.getClass()); TIME_SERVICE.advance(timeout + 1); assertEquals(value, entityCache.get(itemId)); } }
@Test public void concurrentOnlyOneWritesPackedRefs() throws Exception { RevBlob a = tr.blob("a"); tr.lightweightTag("t", a); final CyclicBarrier syncPoint = new CyclicBarrier(2); Callable<Integer> packRefs = new Callable<Integer>() { /** @return 0 for success, 1 in case of error when writing pack */ public Integer call() throws Exception { syncPoint.await(); try { gc.packRefs(); return valueOf(0); } catch (IOException e) { return valueOf(1); } } }; ExecutorService pool = Executors.newFixedThreadPool(2); try { Future<Integer> p1 = pool.submit(packRefs); Future<Integer> p2 = pool.submit(packRefs); assertEquals(1, p1.get().intValue() + p2.get().intValue()); } finally { pool.shutdown(); pool.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS); } }
@Test public void testRemoveUpdateExpiration() throws Exception { CyclicBarrier loadBarrier = new CyclicBarrier(2); CountDownLatch preFlushLatch = new CountDownLatch(1); CountDownLatch flushLatch = new CountDownLatch(1); CountDownLatch commitLatch = new CountDownLatch(1); Future<Boolean> first = removeFlushWait(itemId, loadBarrier, null, flushLatch, commitLatch); Future<Boolean> second = updateFlushWait(itemId, loadBarrier, preFlushLatch, null, commitLatch); awaitOrThrow(flushLatch); Map contents = Caches.entrySet(entityCache).toMap(); assertEquals(1, contents.size()); assertEquals(Tombstone.class, contents.get(itemId).getClass()); preFlushLatch.countDown(); commitLatch.countDown(); first.get(WAIT_TIMEOUT, TimeUnit.SECONDS); second.get(WAIT_TIMEOUT, TimeUnit.SECONDS); contents = Caches.entrySet(entityCache).toMap(); assertEquals(1, contents.size()); assertEquals(Tombstone.class, contents.get(itemId).getClass()); TIME_SERVICE.advance(timeout + 1); assertNull(entityCache.get(itemId)); // force expiration contents = Caches.entrySet(entityCache).toMap(); assertEquals(Collections.EMPTY_MAP, contents); }
@Test public void testValidateConnectionStale() throws Exception { final HttpConnection conn = Mockito.mock(HttpConnection.class); Mockito.when(conn.isOpen()).thenReturn(true); Mockito.when(conn.isStale()).thenReturn(false); final LocalConnFactory connFactory = Mockito.mock(LocalConnFactory.class); Mockito.when(connFactory.create(Mockito.eq("somehost"))).thenReturn(conn); final LocalConnPool pool = new LocalConnPool(connFactory, 2, 10); pool.setValidateAfterInactivity(5); final Future<LocalPoolEntry> future1 = pool.lease("somehost", null); final LocalPoolEntry entry1 = future1.get(1, TimeUnit.SECONDS); Assert.assertNotNull(entry1); pool.release(entry1, true); Thread.sleep(10); Mockito.verify(connFactory, Mockito.times(1)).create("somehost"); Mockito.when(conn.isStale()).thenReturn(true); final Future<LocalPoolEntry> future2 = pool.lease("somehost", null); final LocalPoolEntry entry2 = future2.get(1, TimeUnit.SECONDS); Assert.assertNotNull(entry2); Assert.assertNotSame(entry1, entry2); Mockito.verify(conn, Mockito.times(1)).isStale(); Mockito.verify(conn, Mockito.times(1)).close(); Mockito.verify(connFactory, Mockito.times(2)).create("somehost"); }
/** * Test concurrent reader and writer (GH-458). * * <p><b>Test case:</b> * * <ol> * <li/>start a long running reader; * <li/>try to start a writer: it should time out; * <li/>stop the reader; * <li/>start the writer again: it should succeed. * </ol> * * @throws Exception error during request execution */ @Test @Ignore("There is no way to stop a query on the server!") public void testReaderWriter() throws Exception { final String readerQuery = "?query=(1%20to%20100000000000000)%5b.=1%5d"; final String writerQuery = "/test.xml"; final byte[] content = Token.token("<a/>"); final Get readerAction = new Get(readerQuery); final Put writerAction = new Put(writerQuery, content); final ExecutorService exec = Executors.newFixedThreadPool(2); // start reader exec.submit(readerAction); Performance.sleep(TIMEOUT); // delay in order to be sure that the reader has started // start writer Future<HTTPResponse> writer = exec.submit(writerAction); try { final HTTPResponse result = writer.get(TIMEOUT, TimeUnit.MILLISECONDS); if (result.status.isSuccess()) fail("Database modified while a reader is running"); throw new Exception(result.toString()); } catch (final TimeoutException e) { // writer is blocked by the reader: stop it writerAction.stop = true; } // stop reader readerAction.stop = true; // start the writer again writer = exec.submit(writerAction); assertEquals(HTTPCode.CREATED, writer.get().status); }
// TODO: should this actually throw only ExecutionException? public <T> T callWithTimeout( Callable<T> callable, long timeoutDuration, TimeUnit timeoutUnit, boolean amInterruptible) throws Exception { checkNotNull(callable); checkNotNull(timeoutUnit); checkArgument(timeoutDuration > 0, "bad timeout: " + timeoutDuration); Future<T> future = executor.submit(callable); try { if (amInterruptible) { try { return future.get(timeoutDuration, timeoutUnit); } catch (InterruptedException e) { future.cancel(true); throw e; } } else { Future<T> uninterruptible = Futures.makeUninterruptible(future); return uninterruptible.get(timeoutDuration, timeoutUnit); } } catch (ExecutionException e) { throw Throwables.throwCause(e, true); } catch (TimeoutException e) { future.cancel(true); throw new UncheckedTimeoutException(e); } }
private void releaseTheHounds() { Future<Boolean> future = sparqlOnDemandIndexer.asyncUpdatesAndDeletes(toUpdate, toDelete); boolean success = false; try { success = future.get(120, TimeUnit.SECONDS); } catch (Exception e) { logger.error("Async triplestore update exception", e); } if (!success) { logger.error("Triplestore update timed out, retrying."); future = sparqlOnDemandIndexer.asyncUpdatesAndDeletes(toUpdate, toDelete); try { success = future.get(120, TimeUnit.SECONDS); } catch (Exception e) { logger.error("Async triplestore retry update exception", e); } if (!success) { toUpdate.clear(); toDelete.clear(); throw new RuntimeException("Triplestore update timed out twice, that sux a big one."); } } toUpdate.clear(); toDelete.clear(); }
/** * Makes sure that multiple threads of the same Java process cannot lock the same directory at * once. * * @throws Exception */ @Test public void multipleThreadsOfCurrentJvmSameVersion() throws Exception { final PathLocker<SrcVersion> pathLocker = new PathLocker<>(); final Path dir1 = lockerDirectory.resolve(UUID.randomUUID().toString()); final SrcVersion srcVersion = SrcVersion.parse("1.2.3-SRC-revision-deadbeef"); Future<PathLock> concurrLockFuture = null; try (PathLock lock1 = pathLocker.lockDirectory(dir1, srcVersion)) { /* locked for the current thread */ /* now try to lock from another thread which should fail with a TimeoutException * because we have locked above */ try { concurrLockFuture = lockConcurrently(pathLocker, dir1, srcVersion); concurrLockFuture.get(1, TimeUnit.SECONDS); Assert.fail("TimeoutException expected"); } catch (InterruptedException e) { throw e; } catch (ExecutionException e) { throw e; } catch (TimeoutException e) { /* expected */ } } /* unlocked again - the above attempt to lock from a concurrent thread must succeed now */ PathLock lock2 = concurrLockFuture.get(1, TimeUnit.SECONDS); Assert.assertNotNull(lock2); }
@Test public void testFlush() throws Exception { final int registerCount = 1000; ExecutorService pool = Executors.newCachedThreadPool(); try { final HeapSizeManager underTest = new HeapSizeManager(100l, 100); final AtomicBoolean allOperationsDone = new AtomicBoolean(); final LinkedBlockingQueue<Long> registeredEvents = new LinkedBlockingQueue<>(); Future<?> writeFuture = pool.submit( new Runnable() { @Override public void run() { try { for (int i = 0; i < registerCount; i++) { registeredEvents.offer(underTest.registerOperationWithHeapSize(1)); } underTest.flush(); allOperationsDone.set(true); synchronized (allOperationsDone) { allOperationsDone.notify(); } } catch (InterruptedException e) { e.printStackTrace(); throw new RuntimeException(e); } } }); Thread.sleep(100); Future<?> readFuture = pool.submit( new Runnable() { @Override public void run() { try { for (int i = 0; i < registerCount; i++) { Long registeredId = registeredEvents.poll(1, TimeUnit.SECONDS); if (registeredId == null) { i--; } else { if (i % 50 == 0) { // Exercise the .offer and the flush() in the writeFuture. Thread.sleep(40); } underTest.markCanBeCompleted(registeredId); } } } catch (InterruptedException e) { throw new RuntimeException(e); } } }); readFuture.get(30, TimeUnit.SECONDS); writeFuture.get(30, TimeUnit.SECONDS); assertTrue(allOperationsDone.get()); } finally { pool.shutdownNow(); } }
public void testTakeBlockedByProperty() throws Exception { Slave slave = createSlave(); FreeStyleProject project = createFreeStyleProject(); // First, attempt to run our project before adding the property Future<FreeStyleBuild> build = project.scheduleBuild2(0); assertBuildStatus(Result.SUCCESS, build.get(20, TimeUnit.SECONDS)); // Add the build-blocker property and try again slave.getNodeProperties().add(new RejectAllTasksProperty()); build = project.scheduleBuild2(0); try { build.get(10, TimeUnit.SECONDS); fail("Expected timeout exception"); } catch (TimeoutException e) { List<BuildableItem> buildables = jenkins.getQueue().getBuildableItems(); assertNotNull(buildables); assertEquals(1, buildables.size()); BuildableItem item = buildables.get(0); assertEquals(project, item.task); assertNotNull(item.getCauseOfBlockage()); assertEquals( Messages.Queue_WaitingForNextAvailableExecutor(), item.getCauseOfBlockage().getShortDescription()); } }
/** 存入一个对象 */ private boolean _set(String key, Object value) { // mc1.delete(key); // mc2.delete(key); boolean ret = false; Future<Boolean> f = mc1.set(key, expHour * 60 * 60, value); Future<Boolean> f2 = mc2.set(key, expHour * 60 * 60, value); try { boolean fs1 = f.get(opTimeout, TimeUnit.SECONDS); boolean fs2 = f2.get(opTimeout, TimeUnit.SECONDS); ret = fs1 || fs2; if (!fs1) { log.info( "[FAIL]CACHE SET FAIL:server1 set failed: " + "Key=" + key + "\tValue=" + value.toString()); } else if (!fs2) { log.info( "[FAIL]CACHE SET FAIL:server2 set failed: " + "Key=" + key + "\tValue=" + value.toString()); } } catch (TimeoutException e) { // Since we don't need this, go ahead and cancel the // operation. This // is not strictly necessary, but it'll save some work on // the server. log.info("[FAIL]time out when getting objects from cache server2..."); f.cancel(false); f2.cancel(false); // Do other timeout related stuff } catch (InterruptedException e) { // TODO Auto-generated catch block log.error("[ERROR]exception when setting fengchao cache - thread been interrupted...", e); f.cancel(false); f2.cancel(false); } catch (ExecutionException e) { // TODO Auto-generated catch block log.error( "[ERROR]exception when setting fengchao cache - exception when getting status...", e); f.cancel(false); f2.cancel(false); } catch (Exception e) { log.error("[ERROR]exception when setting fengchao cache - other exceptions...", e); f.cancel(false); f2.cancel(false); } if (value != null) { log.info("MemCacheServiceImpl.set,key=" + key + ",value=" + value.getClass()); } else { log.info("MemCacheServiceImpl.set,key=" + key + ",value=null"); } return ret; }
@Test public void test() throws Exception { AsyncMutex mutex = new AsyncMutex(); final RichFuture<Permit> fPermit1 = mutex.acquire(); final RichFuture<Permit> fPermit2 = mutex.acquire(); final RichFuture<Permit> fPermit3 = mutex.acquire(); assertThat(mutex.getNumPermitsAvailable(), is(0)); assertThat(mutex.getNumWaiters(), is(2)); Permit permit1 = fPermit1.apply(); Future<Permit> waitPermit2 = executor.submit( new Callable<Permit>() { public Permit call() throws Exception { return fPermit2.apply(); } }); Future<Permit> waitPermit3 = executor.submit( new Callable<Permit>() { public Permit call() throws Exception { return fPermit3.apply(); } }); try { waitPermit2.get(10, TimeUnit.MILLISECONDS); fail("permit 2"); } catch (TimeoutException e) { assertTrue(true); } try { waitPermit3.get(10, TimeUnit.MILLISECONDS); fail("permit 3"); } catch (TimeoutException e) { assertTrue(true); } assertThat(mutex.getNumPermitsAvailable(), is(0)); assertThat(mutex.getNumWaiters(), is(2)); permit1.release(); assertThat(mutex.getNumPermitsAvailable(), is(0)); assertThat(mutex.getNumWaiters(), is(1)); Permit permitEither = getEither(waitPermit2, waitPermit3); assertThat(mutex.getNumPermitsAvailable(), is(0)); assertThat(mutex.getNumWaiters(), is(1)); permitEither.release(); assertThat(mutex.getNumPermitsAvailable(), is(0)); assertThat(mutex.getNumWaiters(), is(0)); }
/** * Can be used in test. * * @throws InterruptedException * @throws ExecutionException */ public void waitForBufferReady() throws InterruptedException, ExecutionException { if (currentBufferProvider != null) { currentBufferProvider.get(); } if (bussyBufferProvider != null) { bussyBufferProvider.get(); } }
@Override public BxDocument segmentDocument(BxDocument document) throws AnalysisException { Map<BxPage, List<Component>> componentMap = new HashMap<BxPage, List<Component>>(); ExecutorService exec = Executors.newFixedThreadPool(PdfNLMContentExtractor.THREADS_NUMBER); ArrayList<Callable<NumBxPage>> tasks = new ArrayList<Callable<NumBxPage>>(); for (BxPage page : document.getPages()) { tasks.add(new ComponentCounter(page)); } List<Future<NumBxPage>> results; try { results = exec.invokeAll(tasks); exec.shutdown(); for (Future<NumBxPage> result : results) { NumBxPage p = result.get(); componentMap.put(p.page, p.components); } } catch (ExecutionException ex) { throw new AnalysisException("Cannot segment pages!", ex); } catch (InterruptedException ex) { throw new AnalysisException("Cannot segment pages!", ex); } this.computeDocumentOrientation(componentMap); BxDocument output = new BxDocument(); BxPage[] pages = new BxPage[document.getPages().size()]; exec = Executors.newFixedThreadPool(PdfNLMContentExtractor.THREADS_NUMBER); tasks = new ArrayList<Callable<NumBxPage>>(); int i = 0; for (BxPage page : document.getPages()) { tasks.add(new SingleSegmenter(page, i++)); } try { results = exec.invokeAll(tasks); exec.shutdown(); for (Future<NumBxPage> result : results) { NumBxPage p = result.get(); pages[p.index] = p.page; } for (BxPage p : pages) { if (p.getBounds() != null) { output.addPage(p); } } return output; } catch (ExecutionException ex) { throw new AnalysisException("Cannot segment pages!", ex); } catch (InterruptedException ex) { throw new AnalysisException("Cannot segment pages!", ex); } }
/** * Invokes this method with the provided arguments * * @param args @return @throws WiseException If an unknown exception is received * @throws WiseWebServiceException There are 4 known failure conditions - The wsdl (url) could not * be found - The wsdl is password protected - The endpoint (url) could not be found - The * endpoint is password protected * @throws InvocationException * @throws IllegalArgumentException */ InvocationResultImpl invoke(Map<String, Object> args) throws WiseWebServiceException, InvocationException, IllegalArgumentException { InvocationResultImpl result = null; Map<String, Object> emptyHolder = Collections.emptyMap(); try { EndpointMethodCaller caller = new EndpointMethodCaller( this.getEndpoint(), this.getMethod(), this.getParametersInRightPositionArray(args)); Future<Object> invocation = ((WSEndpointImpl) this.getEndpoint()).getService().submit(caller); if (isOneWay()) { invocation.get(); result = new InvocationResultImpl(null, null, null, emptyHolder); } else { result = new InvocationResultImpl( RESULT, method.getGenericReturnType(), invocation.get(), getHoldersResult(args)); } } catch (java.util.concurrent.ExecutionException wse) { Throwable ite = wse.getCause(); if (ite != null && ite != wse && ite instanceof InvocationTargetException) { Throwable t = ite.getCause(); // unchecked exception ? if (t != null && t != ite && t != wse && t instanceof WebServiceException) { // authentication exception ? if (isAuthenticationException(t, new HashSet<Throwable>())) { throw new WiseWebServiceException( "Authentication exception", null); // TODO improve this } throw new WiseWebServiceException(t.getMessage(), t); } // checked exception ? if (t != null && t != ite && t != wse && t instanceof Exception) { Method methodPointer = this.getMethod(); if (methodPointer != null && methodPointer.getExceptionTypes() != null) { for (int i = 0; i < methodPointer.getExceptionTypes().length; i++) { Class<?> excType = methodPointer.getExceptionTypes()[i]; if (t.getClass().isAssignableFrom(excType)) { // checked exception result = new InvocationResultImpl("exception", excType, t, emptyHolder); return result; } } } } throw new InvocationException("Unknown exception received: " + ite.getMessage(), ite); } throw new WiseWebServiceException(wse.getMessage(), wse); } catch (Throwable e) { throw new InvocationException("Generic Error during method invocation!", e); } return result; }
/** Tests the use of two thread-local tables with same var names and different values */ @Test public void testSetLocalValues() throws Exception { System.out.println(" setLocalValues"); final String key1 = "foo"; final String key2 = "bar"; final Map<String, Object> table0 = new HashMap<String, Object>(); table0.put(key1, 1); table0.put(key2, 2); final Map<String, Object> table1 = new HashMap<String, Object>(); table1.put(key1, 10); table1.put(key2, 20); final List<Map<String, Object>> tables = new ArrayList<Map<String, Object>>(); tables.add(table0); tables.add(table1); final CountDownLatch latch = new CountDownLatch(2); class Task implements Runnable { private final int threadIndex; public Task(int threadIndex) { this.threadIndex = threadIndex; } public void run() { // set the local values for this thread and then wait for // the other thread to do the same before testing EnvFunction.setLocalValues(tables.get(threadIndex)); latch.countDown(); try { latch.await(); } catch (InterruptedException ex) { throw new IllegalStateException(ex); } Map<String, Object> table = tables.get(threadIndex); for (String name : table.keySet()) { Object result = ff.function("env", ff.literal(name)).evaluate(null); int value = ((Number) result).intValue(); assertEquals(table.get(name), value); } } } Future f1 = executor.submit(new Task(0)); Future f2 = executor.submit(new Task(1)); // calling get on the Futures ensures that this test method // completes before another starts f1.get(); f2.get(); }
@Test public void 用途_ワークキュー() throws Exception { o.l1("【どういうこと?】").e(); o.l2("キューイングされたタスクを、順にデキューして、順に別のスレッドで実行。").e(); o.l1("【どうすれば?】").e(); o.l2("java.util.concurrent.Executors.newSingleThreadExecutor()ファクトリメソッドを使用。").e(); o.l1("【たとえば?】").e(); o.l2("newSingleThreadExecutor()でワークキューを作成。").e(); o.l3("タスクがRunnableの場合").e(); NameDecorateRunner runTask1 = new NameDecorateRunner("task1", 2); NameDecorateRunner runTask2 = new NameDecorateRunner("task2", 1); // executeされたタスクは1つの別スレッドで順々に処理される。 ExecutorService executor = Executors.newSingleThreadExecutor(); // 呼び出し順に処理が行われる executor.execute(runTask1); executor.execute(runTask2); // (ゆるやかな)終了指示 executor.shutdown(); // エグゼキューターの完了を待つ executor.awaitTermination(10 /* timeout */, TimeUnit.SECONDS); assertThat(runTask1.name, is("***task1***")); assertThat(runTask2.name, is("***task2***")); o.l3("タスクがCallableの場合").e(); NameDecorateCaller callTask1 = new NameDecorateCaller("task1", 2); NameDecorateCaller callTask2 = new NameDecorateCaller("task2", 1); executor = Executors.newSingleThreadExecutor(); Future<String> future1 = executor.submit(callTask1); Future<String> future2 = executor.submit(callTask2); executor.shutdown(); // 処理の完了を待つ String result1 = future1.get(); String result2 = future2.get(); assertThat(result1, is("###task1###")); assertThat(result2, is("###task2###")); { /** 【補】invokeAllメソッドとinvokeAnyメソッド */ // あるタスクの集まりの完了を待つことができるメソッド。 // invokeAllメソッドは、タスクをすべて実行し、すべての完了を待つ。 // invokeAnyメソッドは、タスクをすべて実行し、どれか1つでも完了することを待つ。 } }
@Test public void multipleThreadsOfCurrentJvmDistinctVersion() throws Exception { final PathLocker<SrcVersion> pathLocker = new PathLocker<>(); final Path dir1 = lockerDirectory.resolve(UUID.randomUUID().toString()); final SrcVersion srcVersion1 = SrcVersion.parse("1.2.3-SRC-revision-deadbeef"); final SrcVersion srcVersion2 = SrcVersion.parse("2.3.4-SRC-revision-coffeebabe"); Future<PathLock> concurrLockFuture = null; try (PathLock lock1 = pathLocker.lockDirectory(dir1, srcVersion1)) { /* locked for the current thread */ /* * now try to lock for a distinct version from another thread which should fail with a * CannotAcquireLockException because we have locked the path above */ try { concurrLockFuture = lockConcurrently(pathLocker, dir1, srcVersion2); concurrLockFuture.get(1, TimeUnit.SECONDS); Assert.fail("CannotAcquireLockException expected"); } catch (InterruptedException e) { throw e; } catch (ExecutionException e) { Assert.assertTrue( "Should throw CannotAcquireLockException", CannotAcquireLockException.class.equals(e.getCause().getClass())); } catch (TimeoutException e) { throw e; } } /* the above concurrent attempt should still fail, even if lock1 has been released in between */ try { concurrLockFuture.get(1, TimeUnit.SECONDS); Assert.fail("CannotAcquireLockException expected"); } catch (ExecutionException e) { Assert.assertTrue( "Should throw CannotAcquireLockException", CannotAcquireLockException.class.equals(e.getCause().getClass())); } /* but a fresh attempt must succeed */ try { Future<PathLock> concurrLockFuture2 = lockConcurrently(pathLocker, dir1, srcVersion2); Assert.assertNotNull(concurrLockFuture2.get(1, TimeUnit.SECONDS)); } catch (InterruptedException e) { throw e; } catch (ExecutionException e) { throw e; } catch (TimeoutException e) { throw e; } }
/** * Algo: - we put the query into the execution pool. - after x ms, if we don't have a result, we * add the queries for the secondary replicas - we take the first answer - when done, we cancel * what's left. Cancelling means: - removing from the pool if the actual call was not started - * interrupting the call if it has started Client side, we need to take into account - a call is * not executed immediately after being put into the pool - a call is a thread. Let's not multiply * the number of thread by the number of replicas. Server side, if we can cancel when it's still * in the handler pool, it's much better, as a call can take some i/o. * * <p>Globally, the number of retries, timeout and so on still applies, but it's per replica, not * global. We continue until all retries are done, or all timeouts are exceeded. */ public synchronized Result call() throws DoNotRetryIOException, InterruptedIOException, RetriesExhaustedException { boolean isTargetReplicaSpecified = (get.getReplicaId() >= 0); RegionLocations rl = getRegionLocations( true, (isTargetReplicaSpecified ? get.getReplicaId() : RegionReplicaUtil.DEFAULT_REPLICA_ID), cConnection, tableName, get.getRow()); ResultBoundedCompletionService<Result> cs = new ResultBoundedCompletionService<Result>(this.rpcRetryingCallerFactory, pool, rl.size()); if (isTargetReplicaSpecified) { addCallsForReplica(cs, rl, get.getReplicaId(), get.getReplicaId()); } else { addCallsForReplica(cs, rl, 0, 0); try { // wait for the timeout to see whether the primary responds back Future<Result> f = cs.poll(timeBeforeReplicas, TimeUnit.MICROSECONDS); // Yes, microseconds if (f != null) { return f.get(); // great we got a response } } catch (ExecutionException e) { throwEnrichedException(e, retries); } catch (CancellationException e) { throw new InterruptedIOException(); } catch (InterruptedException e) { throw new InterruptedIOException(); } // submit call for the all of the secondaries at once addCallsForReplica(cs, rl, 1, rl.size() - 1); } try { try { Future<Result> f = cs.take(); return f.get(); } catch (ExecutionException e) { throwEnrichedException(e, retries); } } catch (CancellationException e) { throw new InterruptedIOException(); } catch (InterruptedException e) { throw new InterruptedIOException(); } finally { // We get there because we were interrupted or because one or more of the // calls succeeded or failed. In all case, we stop all our tasks. cs.cancelAll(); } return null; // unreachable }
@Override public void execute() { // 以目标数据表的字段信息为主 srcTableMetaData.setColumnMetaDatas(tgtTableMetaData.getColumnMetaDatas()); /* 删除目标数据 */ this.delTgtData(); /* 同步数据 */ try { // 同步数据 String sql = tableMetaDataService.getColumnSql(srcTableMetaData, options); LOGGER.info("get src Sql: " + sql); HiveReader hiveReader = new HiveReader( srcJdbcTemplate, sql, srcTableMetaData.getColumnMetaDatas(), queue, cyclicBarrier, isSrcRunning); Future<Boolean> hiveReaderFuture = threadPool.submit(hiveReader); // 与execute相比,线程执行完成以后可以通过引用获取返回值 List<Future<Boolean>> postgresWriterFutureList = new ArrayList<Future<Boolean>>(); // 消费者是否正常返回标志 for (int i = 1; i < SyncConstant.THREAD_POOL_SIZE; i++) { PostgresWriter submitDataToDatabase = new PostgresWriter( tgtJdbcTemplate, tgtTableMetaData, queue, cyclicBarrier, isSrcRunning, isTgtRunning); postgresWriterFutureList.add(threadPool.submit(submitDataToDatabase)); } // 判断返回值 if (!hiveReaderFuture.get()) { LOGGER.error("get-data and submit data result is false"); } for (Future<Boolean> submitDataToDatabaseFuture : postgresWriterFutureList) { if (!submitDataToDatabaseFuture.get()) { LOGGER.error("get-data and submit data result is false"); } } LOGGER.info("同步完成"); } catch (Exception e) { LOGGER.error("get-data and submit data error", e); } }