/** * Somewhat multi-threaded depth-first search. Performs a DFS of the subtrees from the current * node in parallel. * * @param s The tile sequence * @param b The board to search * @param pool The thread pool in which to submit jobs to. * @return The board with the highest evaluation or null if no board can continue. */ private Board solve_pdfs(Board b, ExecutorService pool) { List<Future<Board>> rets = new ArrayList<>(BOARD_WIDTH); Board best = null; int best_score = -1; for (Direction d : directions) { Board n = new Board(b); if (n.move(tileSequence, d)) { rets.add(pool.submit(new ParallelDFS(n))); } } for (Future<Board> ret : rets) { try { Board c = ret.get(); if (c != null) { int score = evaluate(c); if (score > best_score) { best = c; best_score = score; } } } catch (InterruptedException | ExecutionException e) { System.err.println("Error: " + e.getMessage()); } } return best; }
private NormalizedNode<?, ?> readDataViaTransaction( final DOMDataReadTransaction transaction, final LogicalDatastoreType datastore, final YangInstanceIdentifier path) { LOG.trace("Read {} via Restconf: {}", datastore.name(), path); final ListenableFuture<Optional<NormalizedNode<?, ?>>> listenableFuture = transaction.read(datastore, path); if (listenableFuture != null) { Optional<NormalizedNode<?, ?>> optional; try { LOG.debug("Reading result data from transaction."); optional = listenableFuture.get(); } catch (InterruptedException | ExecutionException e) { LOG.warn("Exception by reading {} via Restconf: {}", datastore.name(), path, e); throw new RestconfDocumentedException( "Problem to get data from transaction.", e.getCause()); } if (optional != null) { if (optional.isPresent()) { return optional.get(); } } } return null; }
@Override public <T extends StoredObject> List<T> getStoredObjects(final Class<T> tClass) { List<T> list = Collections.emptyList(); emLock.lock(); try { final Future<List<T>> future = executorService.submit( () -> { final CriteriaBuilder cb = em.getCriteriaBuilder(); final CriteriaQuery<T> cq = cb.createQuery(tClass); final Root<T> root = cq.from(tClass); cq.select(root); final TypedQuery<T> q = em.createQuery(cq); return new ArrayList<>(q.getResultList()); }); list = future.get(); } catch (InterruptedException | ExecutionException e) { logger.log(Level.SEVERE, e.getLocalizedMessage(), e); } finally { emLock.unlock(); } return stripMarkedForRemoval(list); }
/* * @see jgnash.engine.ReminderDAOInterface#getReminderList() */ @Override @SuppressWarnings("unchecked") public List<Reminder> getReminderList() { List<Reminder> reminderList = Collections.emptyList(); emLock.lock(); try { Future<List<Reminder>> future = executorService.submit( () -> { CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<Reminder> cq = cb.createQuery(Reminder.class); Root<Reminder> root = cq.from(Reminder.class); cq.select(root); TypedQuery<Reminder> q = em.createQuery(cq); return stripMarkedForRemoval(new ArrayList<>(q.getResultList())); }); reminderList = future.get(); } catch (final InterruptedException | ExecutionException e) { logger.log(Level.SEVERE, e.getLocalizedMessage(), e); } finally { emLock.unlock(); } return reminderList; }
private CudaEngine(final int deviceId) { exe = Executors.newSingleThreadExecutor(); // mandatory: Only one cuda thread per context Id = deviceId; try { exe.submit( new Runnable() { @Override public void run() { CUdevice device = new CUdevice(); JCudaDriver.cuDeviceGet(device, deviceId); int array[] = {0}; JCudaDriver.cuDeviceGetAttribute( array, CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK, device); maxThreads = (int) Math.sqrt(array[0]); context = new CUcontext(); // JCudaDriver.cuCtxCreate(context, CUctx_flags.CU_CTX_SCHED_BLOCKING_SYNC, // device); JCudaDriver.cuCtxCreate(context, 0, device); CUmodule m = new CUmodule(); initModules(m); for (Kernel k : Kernel.values()) { initFunction(m, k); } // JCudaDriver.cuCtxSetCacheConfig(CUfunc_cache.CU_FUNC_CACHE_PREFER_NONE);> // // JCudaDriver.cuCtxSetSharedMemConfig(CUsharedconfig.CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE); } }) .get(); } catch (InterruptedException | ExecutionException e) { throw new RuntimeException(e.getMessage()); } neigborsPtrs = new HashMap<>(); }
@Override protected void onHandleIntent(Intent intent) { String url = null; String userName = intent.getStringExtra(PROVIDED_USER_NAME); String instrumentName = intent.getStringExtra(PROVIDED_INSTRUMENT); try { url = URLDecoder.decode(getString(R.string.poll_post_url, instrumentName, userName), "UTF-8"); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } if (url == null) return; RequestFuture<String> future = RequestFuture.newFuture(); StringRequest request = new StringRequest(Request.Method.POST, url, future, future); Volley.newRequestQueue(getApplicationContext()).add(request); try { String response = future.get(30, TimeUnit.SECONDS); PostPollDto dto = new Gson().fromJson(response, PostPollDto.class); if (dto.getStatus().toLowerCase().equalsIgnoreCase("ok")) { PreferencesUtil.savePollInstrument(getApplicationContext(), instrumentName); PreferencesUtil.saveUserName(getApplicationContext(), userName); EventBus.getDefault().post(new PollPostEvent()); } else { EventBus.getDefault().post(new PollPostEvent(dto.getMsg())); } } catch (InterruptedException | ExecutionException | TimeoutException e) { EventBus.getDefault().post(new PollPostEvent(e.getLocalizedMessage())); } }
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(); } }
/* * @see jgnash.engine.TransactionDAO#addTransaction(jgnash.engine.Transaction) */ @Override public synchronized boolean addTransaction(final Transaction transaction) { boolean result = false; emLock.lock(); try { Future<Boolean> future = executorService.submit( () -> { em.getTransaction().begin(); em.persist(transaction); transaction.getAccounts().forEach(em::persist); em.getTransaction().commit(); return true; }); result = future.get(); } catch (final InterruptedException | ExecutionException e) { logger.log(Level.SEVERE, e.getLocalizedMessage(), e); } finally { emLock.unlock(); } return result; }
public static void main(String[] args) { Macros.SHIFT_DURATION = 24 * 60; Schedule schedule = new Schedule(); schedule.addJob(new Job("J1", 10 * 24, 200, Job.JOB_NORMAL)); schedule.addJob(new Job("J2", 10 * 24, 200, Job.JOB_NORMAL)); schedule.addJob(new Job("J3", 10 * 24, 200, Job.JOB_NORMAL)); schedule.addJob(new Job("J4", 10 * 24, 200, Job.JOB_NORMAL)); schedule.addJob(new Job("J5", 10 * 24, 200, Job.JOB_NORMAL)); schedule.addJob(new Job("J6", 10 * 24, 200, Job.JOB_NORMAL)); // machine = new Machine(0,1); pmoList = schedule.getPMOpportunities(); ExecutorService threadPool = Executors.newSingleThreadExecutor(); CompletionService<SimulationResult> pool = new ExecutorCompletionService<SimulationResult>(threadPool); pool.submit( new SimulationThread( schedule, getCombolist((long) (Math.pow(2, 31) - 1)), pmoList, false, machine)); try { SimulationResult result = pool.take().get(); System.out.println(result.cost); } catch (InterruptedException | ExecutionException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
@Override public List<TrashObject> getTrashObjects() { List<TrashObject> trashObjectList = Collections.emptyList(); emLock.lock(); try { final Future<List<TrashObject>> future = executorService.submit( () -> { final CriteriaBuilder cb = em.getCriteriaBuilder(); final CriteriaQuery<TrashObject> cq = cb.createQuery(TrashObject.class); final Root<TrashObject> root = cq.from(TrashObject.class); cq.select(root); final TypedQuery<TrashObject> q = em.createQuery(cq); return new ArrayList<>(q.getResultList()); }); trashObjectList = future.get(); } catch (final InterruptedException | ExecutionException e) { logger.log(Level.SEVERE, e.getLocalizedMessage(), e); } finally { emLock.unlock(); } return trashObjectList; }
/** @see jgnash.engine.dao.TransactionDAO#getTransactions() */ @Override @SuppressWarnings("unchecked") public List<Transaction> getTransactions() { List<Transaction> transactionList = Collections.emptyList(); emLock.lock(); try { Future<List<Transaction>> future = executorService.submit( () -> { Query q = em.createQuery("SELECT t FROM Transaction t WHERE t.markedForRemoval = false"); return new ArrayList<>(q.getResultList()); }); transactionList = future.get(); } catch (final InterruptedException | ExecutionException e) { logger.log(Level.SEVERE, e.getLocalizedMessage(), e); } finally { emLock.unlock(); } return transactionList; }
public static <T> List<T> execiteMyTask(String sql) { ExecutorService threadPool = Executors.newFixedThreadPool(8); final List<T> batches = new ArrayList<T>(); Callable<T> t = new Callable<T>() { public T call() { T result = callDatabase(sql); synchronized (batches) { batches.add(result); } return result; } private T callDatabase(String sql) { // TODO Auto-generated method stub return null; } }; Future<T> f = threadPool.submit(t); try { T result = f.get(); } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); } return batches; }
public void createEntry(Map<String, String> data) { if (data == null || data.isEmpty()) { log.debug("empty input data"); return; } List<EntryField> fields = new ArrayList<>(); for (String key : data.keySet()) { EntryFieldBuilder fieldBuilder = new EntryFieldBuilder(); fieldBuilder.setKey(key); fieldBuilder.setValue(data.get(key)); fields.add(fieldBuilder.build()); } SaveEntryInputBuilder inputbuilder = new SaveEntryInputBuilder(); inputbuilder.setEntryId(String.valueOf(rand.nextInt(1000000000))); inputbuilder.setEntryField(fields); try { RpcResult<Void> result = service.saveEntry(inputbuilder.build()).get(); if (result.isSuccessful()) { log.debug("Successfully Added entry"); } } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); } }
@Override public void remove(final TrashObject trashObject) { emLock.lock(); try { final Future<Void> future = executorService.submit( () -> { em.getTransaction().begin(); final StoredObject object = trashObject.getObject(); em.remove(object); em.remove(trashObject); logger.info("Removed TrashObject"); em.getTransaction().commit(); return null; }); future.get(); // block } catch (final InterruptedException | ExecutionException e) { logger.log(Level.SEVERE, e.getLocalizedMessage(), e); } finally { emLock.unlock(); } }
@Override public ArrayList<String> autocomplete(String input) { ArrayList<String> resultList = null; String url = Urls.getAutocompleteUrl(input); RequestFuture<JSONObject> future = RequestFuture.newFuture(); JsonObjectRequest request = new JsonObjectRequest(url, null, future, future); requestQueue.add(request); try { JSONObject response = future.get(10, TimeUnit.SECONDS); JSONArray predictions = response.getJSONArray("predictions"); // Extract the Place descriptions from the results resultList = new ArrayList<String>(predictions.length()); for (int i = 0; i < predictions.length(); i++) { JSONArray terms = predictions.getJSONObject(i).getJSONArray("terms"); resultList.add(terms.getJSONObject(0).getString("value")); } } catch (InterruptedException | ExecutionException | TimeoutException | JSONException e) { e.printStackTrace(); } return resultList; }
@Override protected void done() { hashDb.indexing = false; progress.finish(); // see if we got any errors try { get(); } catch (InterruptedException | ExecutionException ex) { logger.log(Level.SEVERE, "Error creating index", ex); // NON-NLS MessageNotifyUtil.Notify.show( NbBundle.getMessage(this.getClass(), "HashDbManager.errCreatingIndex.title"), NbBundle.getMessage( this.getClass(), "HashDbManager.errCreatingIndex.msg", ex.getMessage()), MessageNotifyUtil.MessageType.ERROR); } // catch and ignore if we were cancelled catch (java.util.concurrent.CancellationException ex) { } try { hashDb.propertyChangeSupport.firePropertyChange( HashDb.Event.INDEXING_DONE.toString(), null, hashDb); hashDb.propertyChangeSupport.firePropertyChange( HashDbManager.SetEvt.DB_INDEXED.toString(), null, hashDb.getHashSetName()); } catch (Exception e) { logger.log(Level.SEVERE, "HashDbManager listener threw exception", e); // NON-NLS MessageNotifyUtil.Notify.show( NbBundle.getMessage(this.getClass(), "HashDbManager.moduleErr"), NbBundle.getMessage(this.getClass(), "HashDbManager.moduleErrorListeningToUpdatesMsg"), MessageNotifyUtil.MessageType.ERROR); } }
public static void main(String[] args) { ExecutorService executorService = Executors.newFixedThreadPool(NUM_THREADS); List<Future<Long>> summationTasks = new ArrayList<>(); long nByTen = N / 10; for (int i = 0; i < NUM_THREADS; i++) { long fromInnerRange = (nByTen * i) + 1; long toInnerRange = nByTen * (i + 1); System.out.printf( "Spawning threads for summing in range %d to %d %n", fromInnerRange, toInnerRange); Callable<Long> summationTask = new SumClass(fromInnerRange, toInnerRange); Future<Long> futureSum = executorService.submit(summationTask); summationTasks.add(futureSum); } for (Future<Long> partialSum : summationTasks) { try { calculatedSum += partialSum.get(); } catch (InterruptedException | ExecutionException e) { // TODO Auto-generated catch block e.printStackTrace(); } } long formulaSum = (N * (N + 1)) / 2; System.out.printf("Sum by threads = %d, sum using the formula = %d", calculatedSum, formulaSum); }
@Override public CommandResult execute(CommandSource src, CommandContext args) throws CommandException { if (!args.hasAny("old")) { src.sendMessage(invalidArg()); return CommandResult.empty(); } String oldWorldName = args.<String>getOne("old").get(); if (oldWorldName.equalsIgnoreCase("@w")) { if (src instanceof Player) { oldWorldName = ((Player) src).getWorld().getName(); } } if (!args.hasAny("new")) { src.sendMessage(invalidArg()); return CommandResult.empty(); } String newWorldName = args.<String>getOne("new").get(); for (WorldProperties world : Main.getGame().getServer().getAllWorldProperties()) { if (!world.getWorldName().equalsIgnoreCase(newWorldName)) { continue; } src.sendMessage(Text.of(TextColors.DARK_RED, newWorldName, " already exists")); return CommandResult.empty(); } if (!Main.getGame().getServer().getWorld(oldWorldName).isPresent()) { src.sendMessage(Text.of(TextColors.DARK_RED, "World ", oldWorldName, " does not exists")); return CommandResult.empty(); } Optional<WorldProperties> copy = null; try { copy = Main.getGame() .getServer() .copyWorld( Main.getGame().getServer().getWorld(oldWorldName).get().getProperties(), newWorldName) .get(); } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); } if (!copy.isPresent()) { src.sendMessage(Text.of(TextColors.DARK_RED, "Could not copy ", oldWorldName)); return CommandResult.empty(); } src.sendMessage(Text.of(TextColors.DARK_GREEN, oldWorldName, " copied to ", newWorldName)); return CommandResult.success(); }
private JSONObject encrypt(JSONObject plain) { JSONObject result = null; try { result = Utils.encrypt(plain, preparePublicKey.get()); } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); } return result; }
@Override protected void done() { super.done(); try { instance.put(imagePath, get()); } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); } }
@RequestMapping("/hello/contacts") @ResponseStatus(HttpStatus.OK) public DeferredResult<ResponseEntity<List<Contact>>> contacts( @RequestParam(value = "nameFilter") String regexp, HttpServletRequest request) { identifier = "ip:" + getClientIpAddress(request) + ", sessionId:" + RequestContextHolder.currentRequestAttributes().getSessionId(); logger.info("Client [" + identifier + "] was connected."); if (regexp == null || regexp.isEmpty()) { logger.error("The 'nameFilter' parameter must not be null or empty"); throw new IllegalArgumentException("The 'nameFilter' parameter must not be null or empty"); } DeferredResult<ResponseEntity<List<Contact>>> deferredResult = new DeferredResult<>(); ResponseEntity<List<Contact>> response = null; Future<List<Contact>> asyncResponse = contactService.getContacts(regexp); try { response = new ResponseEntity<>(asyncResponse.get(timeout, TimeUnit.SECONDS), HttpStatus.OK); deferredResult.setResult(response); logger.info("Request was executed successfully for client [" + identifier + "]"); } catch (TimeoutException e) { logger.error("Request has timed out for [" + identifier + "]", e); deferredResult.setErrorResult( new ResponseEntity<>("Sorry.Request has timed out.", HttpStatus.REQUEST_TIMEOUT)); } catch (InterruptedException | ExecutionException e) { if (e.getCause() instanceof PersistenceException) { logger.error("Database is not available.", e); deferredResult.setErrorResult( new ResponseEntity<String>( "Sorry.Database is not available.", HttpStatus.SERVICE_UNAVAILABLE)); } else { logger.error("Contacts processing was interrrupted or aborted for [" + identifier + "]", e); deferredResult.setErrorResult( new ResponseEntity<>( "Sorry.Contacts processing was interrrupted or aborted.", HttpStatus.SERVICE_UNAVAILABLE)); } } return deferredResult; }
@Override protected void onPostExecute(Integer result) { if (dialog.isShowing()) dialog.dismiss(); if (listener != null) { try { listener.processFinish(result); } catch (InterruptedException | ExecutionException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
@Override public void logOut(String token) throws SynchronizationException { try { ResponseSerializer response = new LogOutAsyncTask(token).execute().get(); if (validateServerResponse(response)) { TOKEN = null; USER_ACCOUNT = null; } } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); } }
@Test public void testUpdate() { UpdateRequest updateRequest = new UpdateRequest("asdf2014", "asdf", "1").script("ctx._source.sex=\"man\""); try { client.update(updateRequest).get(); } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); throw new RuntimeException(e); } }
@Override public double[] getLogLikelihoods(List<Beacon> beacons, State[] locations) { List<Beacon> beaconsCleansed = Beacon.filterBeacons(beacons, minRssi, maxRssi); beaconsCleansed = beaconFilter.setBLEBeacon(bleBeacons).filter(beaconsCleansed, locations); BLEBeacon.setBLEBeaconIdsToMeasuredBeacons(bleBeacons, beaconsCleansed); int[] activeBeaconList = ModelAdaptUtils.beaconsToActiveBeaconArray(beaconsCleansed); final double[] ySub = ModelAdaptUtils.beaconsToVecSubset(beaconsCleansed); final double[][] X = ModelAdaptUtils.locationsToMat(locations); // Adjust bias by average bias final double[] rssiBiases = ModelAdaptUtils.biasesToVec(locations); double logLLs[] = null; try { Class<?> cls = gpLDPL.getClass(); Constructor<?> cst = cls.getConstructor(gpLDPL.getClass()); final GaussianProcessLDPLMean gpLDPLtmp = (GaussianProcessLDPLMean) cst.newInstance(gpLDPL); gpLDPLtmp.updateByActiveBeaconList(activeBeaconList); int n = X.length; final double logpro[] = new double[n]; Future<?>[] futures = new Future<?>[n]; for (int i = 0; i < n; i++) { final int idx = i; futures[idx] = ExecutorServiceHolder.getExecutorService() .submit( new Runnable() { public void run() { // Subtract bias from an observation vector. double[] ySubAdjusted = ArrayUtils.addScalar(ySub, -rssiBiases[idx]); logpro[idx] = gpLDPLtmp.logProbaygivenx(X[idx], ySubAdjusted); } }); } for (int i = 0; i < n; i++) { futures[i].get(); } logLLs = logpro; } catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException | SecurityException e) { e.printStackTrace(); } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); } return logLLs; }
@Override protected void done() { FlightConditions fc; try { fc = get(); NotificationCenter.getInstance() .notify(AirnoiseNotifications.FLIGHT_CONDITIONS_UPDATED, this, fc); this.progressBar.dispose(); } catch (InterruptedException | ExecutionException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
/* * Implements an abstract method from VizConnection. */ @Override protected boolean disconnectFromWidget(IParaViewWebClient widget) { boolean closed = false; // Attempt to disconnect, returning the success of the operation. if (widget != null) { try { closed = widget.disconnect().get(); } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); } } return closed; }
static void runExample() { ExecutorService es = Executors.newFixedThreadPool(2); Future<Integer> f = es.submit(new Calculator()); try { System.out.println("Result: " + f.get()); } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); } es.shutdown(); }
@Override public void done() { try { get(); } catch (InterruptedException | ExecutionException ex) { System.err.println(ex.getCause()); setProgressNote(String.format("%s\n", UiString.get(_S1))); } catch (CancellationException ex) { // cancelled by user. } setProgressNote(""); setProgress(0); }
public static void main(String[] args) throws IOException { String workDir = "E:/dev_workspace/tmp/workspace/duc2007"; String idfFilename = "duc2007.idf"; final double TOTAL_PAGE_COUNT = 30000000000.0D; Map<String, Double> idfValues = new HashMap<String, Double>(); File idfFIle = FileUtils.getFile(workDir + "/" + DIR_IDF_FILE, idfFilename); log.info("Loading idf value file[" + idfFIle.getAbsolutePath() + "]"); LineIterator lineIterator = null; try { lineIterator = FileUtils.lineIterator(idfFIle, DEFAULT_CHARSET.toString()); while (lineIterator.hasNext()) { String line = lineIterator.nextLine(); String[] strs = line.split("###"); if (strs.length != 2) { log.warn("Line[" + line + "] format is illegal, ignore it!"); continue; } idfValues.put(strs[0].trim(), Long.parseLong(strs[1]) / TOTAL_PAGE_COUNT); } log.info("Load idf value file[" + idfFIle.getAbsolutePath() + "] finished!"); } catch (IOException e) { log.error("Load idf value file[" + idfFIle.getAbsolutePath() + "] error!", e); throw e; } finally { if (lineIterator != null) { lineIterator.close(); } } String question = "Describe the legal battle between various recording artists and members of the record industry and the Internet music site Napster. What support, or lack thereof, have the litigants received?"; EhCacheUtil ehCacheUtil = new EhCacheUtil("db_cache_vec", "lab"); SummaryBuilderByVector summaryBuilder = new SummaryBuilderByVector( workDir, "0", "D0714D.txt", 10, idfValues, question, ehCacheUtil, 1.0f, 1.6f); ExecutorService es = Executors.newSingleThreadExecutor(); Future<Boolean> future = es.submit(summaryBuilder); try { future.get(); } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); } es.shutdown(); EhCacheUtil.close(); }