标签: executorservice

我正在尝试对中的getPrice每个方法进行并行调用。我有这段代码并验证了 getPrice 正在单独的线程中运行，但它们是按顺序运行的，而不是并行运行的。谁能指出我在这里缺少什么吗？productproducts

非常感谢你的帮助。

   ExecutorService service = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
   Set<Product> decoratedProductSet = products.stream()
   .map(product -> CompletableFuture
                             .supplyAsync(() -> getPrice(product.getId(), date, context), service))
   .map(t -> t.exceptionally(throwable -> null))
   .map(t -> t.join())
   .collect(Collectors.<Product>toSet());

我有一个文件列表和一个分析这些文件的分析器列表。文件数量可能很大（200,000 个），分析器数量可能很大（1000 个）。因此操作总数可能非常大（200,000,000）。现在，我需要应用多线程来加快速度。我遵循了这种方法：

ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
for (File file : listOfFiles) {
  for (Analyzer analyzer : listOfAnalyzers){
    executor.execute(() -> {
      boolean exists = file.exists();
      if(exists){
        analyzer.analyze(file);
      }
    });
  }
}
executor.shutdown();
executor.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);

但这种方法的问题是它从内存中获取了太多内容，我想有更好的方法来做到这一点。我还是java和多线程的初学者。

我正在运行一个使用固定线程池的 Java 应用程序，其中线程用于向外部服务发出 HTTP 请求。

线程池被故意过度配置，我想获得一些线程池利用率的测量结果（即，此时池中 20% 的线程空闲，而此时 30% 的线程忙碌）。

是否有一种有效的方法来检查线程池（通过 Executors.newFixedThreadPool(x) 创建）当前正在执行任务的比例？

我曾考虑过创建一个特殊的监视器线程来持续运行可调用任务，报告利用率，但我不确定这是否会影响线程池本身的性能（通过使线程响应监视器而不是进行 HTTP 调用） ）。

我是ExecutorService的新手,但我不确定我的方法.对于已知任务,我可以处理多达100个线程.我正在使用下面的通用格式,在那里我创建了FutureTasks列表,然后将它们提交给ExecutorService.ExecutorService返回并将这些挂起的结果添加到另一个列表中.然后我迭代这个列表,在每个挂起的结果上调用get().

我的查询是:直到所有100个线程都完成后,依次不会在每个get()上阻塞吗？有一个更好的方法吗 ？

我是否正确假设get()返回Callable实现的call()方法的结果？我正在使用默认的FutureTask类,并没有将其子类化.

ExecutorService exec = Executors.newFixedThreadPool( NUM_THREADS );

List<JobClass> originalList = new ArrayList<JobClass>();

List<SomeOtherClass> pendingResult = new ArrayList<SomeOtherClass>();

List<Future<SomeOtherClass>> resultList = new ArrayList<Future<SomeOtherClass>>();

for( JobClass sc : originalList )
    pendingResult.add( submit( sc );

for( Future<SomeOtherClass> future : futures )
    resultList.add( future.get(5, TimeUnit.SECONDS) ); 

我有一个代码片段,其中一个循环提交Callable,然后检查这些是否已完成,如果是,则打印出它们的值

    ArrayList<Future<ArrayList<String>>> controllList = new  ArrayList<Future<ArrayList<String>>>();
    System.out.println(""+pagecount);
    for(int n=1;n<=pagecount;n++){
        if(controllList.size()<10){
            Future<ArrayList<String>> temp = exeService.submit(new URLSpider("localhost"));
            controllList.add(temp);
        }
        for(int k=0;k<controllList.size();k++){
            if(controllList.get(k).isDone()){
                System.out.println("Something done");
                ArrayList<String> URLs = controllList.get(k).get();
                for(int h=0;h<URLs.size();h++){
                    System.out.println(URLs.get(h));
                }
                controllList.remove(k);
            }
        }
    }

URLSpider类:

public class URLSpider implements Callable<ArrayList<String>> {
private TagNode node;
private String pageUrl;
private Object[] links;
private ArrayList<String> detailLinks;


public URLSpider(String completePageURL){
    pageUrl = completePageURL;
    detailLinks = new ArrayList<String>();
}
@Override
public ArrayList<String> call() throws Exception {
    HtmlCleaner cleaner = new HtmlCleaner();

    try {
        node = …

我有两个线程t1和t2.他们两个都进行了一些计算,我试着阻止主线程直到t1和t2完成.我使用.awaitTermination()如下所示,但问题是,despit它是一个if语句,.awaitTermination()进入无限循环.

请帮助我找到正在发生的事情.我应该在不知道t1和t2需要完成的确切时间的情况下指定一段时间吗？

 executor.execute(new RunnableClass(bgr,3))
 executor.execute(new RunnableClass(bgr,7))
 executor.shutdown();

if (executor.awaitTermination(3, TimeUnit.SECONDS)) {
    print("terminated")
}

我在for循环中创建了几个线程,如下所示:

for (int i = 0; i<5; i++) {
   new Thread() {
       //do stuff
   }
}

但我需要确保这些线程一个接一个地执行,而不是同时执行.

做这个的最好方式是什么？

我们在java中有三种不同的多线程技术 - Fork/Join池,Executor Service和CountDownLatch

Fork/Join pool(http://www.javacodegeeks.com/2011/02/java-forkjoin-parallel-programming.html)

Fork/Join框架旨在使分而治之的算法易于并行化.这种类型的算法非常适合于可以分为两个或更多相同类型的子问题的问题.他们使用递归将问题分解为简单的任务,直到这些变得足够简单直接解决.然后组合子问题的解决方案以给出原始问题的解决方案

ExecutorService是一个扩展Executor类并表示异步执行的接口.它为我们提供了管理结束和检测异步任务进度的机制.

invokeAll():执行给定的任务,返回一个Futures列表,其中包含完成后的状态和结果.对于返回列表的每个元素,Future.isDone()都为true.

CountDownLatch :( http://examples.javacodegeeks.com/core-java/util/concurrent/countdownlatch-concurrent/java-util-concurrent-countdownlatch-example/)

CountDownLatch用于同步,以允许一个或多个线程等待,直到在其他线程中执行的一组操作完成.

我的假设:

在这两种替代方案中,只有在完成所有任务/线程后才能知道最终结果.

这三种选择是互补的还是互补的？

我有一种情况，我需要检查是否满足特定条件，并且需要在声明不满足条件之前定期执行一定次数以检查条件，并且每次执行之间都需要延迟/睡眠间隔。

代码结构：

class checkCondition<T> implements Callable<T>{
 @Override
public T call() {
//Do Stuff and return result
return result;
}
public class TaskRunner<T> {
private final ExecutorService executor = Executors.newSingleThreadExecutor();
public Future<T> runTask(checkCondiiton task, int times, long sleep){

while(times > 0){
future = executor.submit(task);
Thread.sleep(sleep);
times--;
}
return future;
}
}

}

上面的实现正确吗？如果没有，请建议哪种方法更好。我是ExecutorService和Java Concurrency的新手。

我正在尝试编写一个程序,将几个java工作线程之间的工作分开.问题是,当我从命令行运行它时,它永远不会返回.我没有得到我的提示,最终必须按ctrl-c关闭程序.

我把它简化为以下简单的案例

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class TestExeServ {

    private class ExpensiveTask implements Callable<Integer>{
        private final String msg; 
        public ExpensiveTask(String str){
            this.msg = str;
        }

        @Override
        public Integer call()  {
            System.out.println( "My message was " + msg);
            return 1;
        }
    }

    private void run()
    {
        final ExecutorService exeServ = Executors.newFixedThreadPool(2);
        Future<Integer> result = exeServ.submit(new ExpensiveTask("Hello!") );
        try {
            System.out.println( " Task is done, it returned " + result.get());
        } catch (Exception e) {
            e.printStackTrace();
        } …