How to use

ExecutorUtil

in

org.apache.solr.common.util

private void closeCallbackExecutor() {
 try {
  ExecutorUtil.shutdownAndAwaitTermination(zkCallbackExecutor);
 } catch (Exception e) {
  SolrException.log(log, e);
 }
 try {
  ExecutorUtil.shutdownAndAwaitTermination(zkConnManagerCallbackExecutor);
 } catch (Exception e) {
  SolrException.log(log, e);
 }
}

/**
 * Create a cached thread pool using a named thread factory
 */
public static ExecutorService newMDCAwareCachedThreadPool(String name) {
 return newMDCAwareCachedThreadPool(new SolrjNamedThreadFactory(name));
}

public static void shutdownAndAwaitTermination(ExecutorService pool) {
 pool.shutdown(); // Disable new tasks from being submitted
 awaitTermination(pool);
}

public void open() throws IOException {
 executorService = ExecutorUtil.newMDCAwareFixedThreadPool(threads, new SolrjNamedThreadFactory("ExecutorStream"));
 stream.open();
}

/**
 * @lucene.experimental
 */
public HttpUriRequestResponse httpUriRequest(final SolrRequest request, final ResponseParser processor) throws SolrServerException, IOException {
 HttpUriRequestResponse mrr = new HttpUriRequestResponse();
 final HttpRequestBase method = createMethod(request, null);
 ExecutorService pool = ExecutorUtil.newMDCAwareFixedThreadPool(1, new SolrjNamedThreadFactory("httpUriRequest"));
 try {
  MDC.put("HttpSolrClient.url", baseUrl);
  mrr.future = pool.submit(new Callable<NamedList<Object>>(){
   @Override
   public NamedList<Object> call() throws Exception {
    return executeMethod(method, processor);
   }});
 } finally {
  pool.shutdown();
  MDC.remove("HttpSolrClient.url");
 }
 assert method != null;
 mrr.httpUriRequest = method;
 return mrr;
}

public void close() {
 this.closed  = true;
 notifications.shutdown();
 ExecutorUtil.shutdownAndAwaitTermination(collectionPropsNotifications);
 if (closeClient) {
  zkClient.close();
 }
}

public ConcurrentUpdateSolrClient(String solrServerUrl,
                 HttpClient client, int queueSize, int threadCount) {
 this(solrServerUrl, client, queueSize, threadCount, ExecutorUtil.newMDCAwareCachedThreadPool(
   new SolrjNamedThreadFactory("concurrentUpdateScheduler")));
 shutdownExecutor = true;
}

/**
 * @lucene.experimental
 */
public HttpUriRequestResponse httpUriRequest(final SolrRequest request, final ResponseParser processor) throws SolrServerException, IOException {
 HttpUriRequestResponse mrr = new HttpUriRequestResponse();
 final HttpRequestBase method = createMethod(request, null);
 ExecutorService pool = ExecutorUtil.newMDCAwareFixedThreadPool(1, new SolrjNamedThreadFactory("httpUriRequest"));
 try {
  MDC.put("HttpSolrClient.url", baseUrl);
  mrr.future = pool.submit(() -> executeMethod(method, processor, isV2ApiRequest(request)));
 } finally {
  pool.shutdown();
  MDC.remove("HttpSolrClient.url");
 }
 assert method != null;
 mrr.httpUriRequest = method;
 return mrr;
}

private void closeCallbackExecutor() {
 try {
  ExecutorUtil.shutdownAndAwaitTermination(zkCallbackExecutor);
 } catch (Exception e) {
  SolrException.log(log, e);
 }
}

private void openStreams() throws IOException {
 ExecutorService service = ExecutorUtil.newMDCAwareCachedThreadPool(new SolrjNamedThreadFactory("TopicStream"));
 try {
  List<Future<TupleWrapper>> futures = new ArrayList();
  for (TupleStream solrStream : solrStreams) {
   StreamOpener so = new StreamOpener((SolrStream) solrStream, comp);
   Future<TupleWrapper> future = service.submit(so);
   futures.add(future);
  }
  try {
   for (Future<TupleWrapper> f : futures) {
    TupleWrapper w = f.get();
    if (w != null) {
     tuples.add(w);
    }
   }
  } catch (Exception e) {
   throw new IOException(e);
  }
 } finally {
  service.shutdown();
 }
}

threadPool = ExecutorUtil.newMDCAwareFixedThreadPool(threads, new SolrjNamedThreadFactory("ShortestPathStream"));

public static void tryClose() {
 Set<Entry<Object,String>> entries = OBJECTS.entrySet();
 if (entries.size() > 0) {
  for (Entry<Object,String> entry : entries) {
   if (entry.getKey() instanceof Closeable) {
    try {
     ((Closeable)entry.getKey()).close();
    } catch (Throwable t) {
     log.error("", t);
    }
   } else if (entry.getKey() instanceof ExecutorService) {
    try {
     ExecutorUtil.shutdownAndAwaitTermination((ExecutorService)entry.getKey());
    } catch (Throwable t) {
     log.error("", t);
    }
   }
  }
 }
}

private void openStreams() throws IOException {
 ExecutorService service = ExecutorUtil.newMDCAwareCachedThreadPool(new SolrjNamedThreadFactory("CloudSolrStream"));
 try {
  List<Future<TupleWrapper>> futures = new ArrayList();
  for (TupleStream solrStream : solrStreams) {
   StreamOpener so = new StreamOpener((SolrStream) solrStream, comp);
   Future<TupleWrapper> future = service.submit(so);
   futures.add(future);
  }
  try {
   for (Future<TupleWrapper> f : futures) {
    TupleWrapper w = f.get();
    if (w != null) {
     tuples.add(w);
    }
   }
  } catch (Exception e) {
   throw new IOException(e);
  }
 } finally {
  service.shutdown();
 }
}

threadPool = ExecutorUtil.newMDCAwareFixedThreadPool(4, new SolrjNamedThreadFactory("GatherNodesStream"));

ExecutorUtil.shutdownAndAwaitTermination(executorLauncher);
ExecutorUtil.shutdownAndAwaitTermination(executorCloser);
try {
 if (!externalZkServer) {

private void openStreams() throws IOException {
 ExecutorService service = ExecutorUtil.newMDCAwareCachedThreadPool(new SolrjNamedThreadFactory("CloudSolrStream"));
 try {
  List<Future<TupleWrapper>> futures = new ArrayList();
  for (TupleStream solrStream : solrStreams) {
   StreamOpener so = new StreamOpener((SolrStream) solrStream, comp);
   Future<TupleWrapper> future = service.submit(so);
   futures.add(future);
  }
  try {
   for (Future<TupleWrapper> f : futures) {
    TupleWrapper w = f.get();
    if (w != null) {
     tuples.add(w);
    }
   }
  } catch (Exception e) {
   throw new IOException(e);
  }
 } finally {
  service.shutdown();
 }
}

 return true;
} finally {
 ExecutorUtil.shutdownAndAwaitTermination(executor);
 float secs = (System.nanoTime() - start) / (float)(1.0e9);
 LOG.info("Live merging of index shards into Solr cluster took " + secs + " secs");

public void open() throws IOException {
 if (cache == null) {
  isCloseCache = true;
  cache = new SolrClientCache();
 } else {
  isCloseCache = false;
 }
 this.executorService = ExecutorUtil.newMDCAwareCachedThreadPool(new SolrjNamedThreadFactory("SignificantTermsStream"));
}

 return true;
} finally {
 ExecutorUtil.shutdownAndAwaitTermination(executor);
 float secs = (System.nanoTime() - start) / (float)(1.0e9);
 LOG.info("Live merging of index shards into Solr cluster took " + secs + " secs");

protected ConcurrentUpdateSolrClient(Builder builder) {
 this.internalHttpClient = (builder.httpClient == null);
 this.client = new HttpSolrClient.Builder(builder.baseSolrUrl)
   .withHttpClient(builder.httpClient)
   .build();
 this.client.setFollowRedirects(false);
 this.queue = new LinkedBlockingQueue<>(builder.queueSize);
 this.threadCount = builder.threadCount;
 this.runners = new LinkedList<>();
 this.streamDeletes = builder.streamDeletes;
 this.connectionTimeout = builder.connectionTimeoutMillis;
 this.soTimeout = builder.socketTimeoutMillis;
 
 if (builder.executorService != null) {
  this.scheduler = builder.executorService;
  this.shutdownExecutor = false;
 } else {
  this.scheduler = ExecutorUtil.newMDCAwareCachedThreadPool(new SolrjNamedThreadFactory("concurrentUpdateScheduler"));
  this.shutdownExecutor = true;
 }
 
 if (log.isDebugEnabled()) {
  this.pollInterrupts = new AtomicInteger();
  this.pollExits = new AtomicInteger();
  this.blockLoops = new AtomicInteger();
  this.emptyQueueLoops = new AtomicInteger();
 }
}