标签: executors

我的理解是它看起来与抽象工厂非常相似。

笔记：

执行器界面：

public interface Executor {
     public void execute();
}

然后是一个Executors包含各种Executor实现的静态工厂的类。

我确信我可以将一些东西放在一起,这可以让我弄清楚这一点,但我希望有一个我只是缺少的开箱即用的解决方案.我阅读了文档,但我没有看到任何内容.

我的特定应用程序使用的是a ThreadPoolExecutor支持DelayQueue,虽然我不确定这是否重要.

谢谢!

我正在尝试创建一个ThreadPoolExecutor:

// Thingy implements Delayed and Runnable
ExecutorService executor = new ThreadPoolExecutor(1, 1, 0l, TimeUnit.SECONDS, new DelayQueue<Thingy>());

编译器说"找不到符号":

symbol  : constructor ThreadPoolExecutor(int,int,long,java.util.concurrent.TimeUnit,java.util.concurrent.DelayQueue<Thingy>)

但我不明白 - DelayQueue实现BlockingQueue,所以我不能使用这个构造函数？

我有一个单线程执行器服务,用于通过网络获取一些数据.

当用户在搜索框中键入时,我正在排队可能的网络任务.我想要的是取消所有以前的请求,只排队并立即运行最新的请求.

我目前的方法是覆盖execute()和submit()方法并在调用super之前清除队列.

有什么想法吗？

我试图从java.util.concurrent包中模拟ExecutorService和Executors.

如果我试图在同一个类(测试类)中获取对象,我可以获取模拟对象.但是,如果我尝试在另一个类(我想要测试的类)中获取模拟对象,那么它将从java.util.concurrent返回实际对象.以下是代码段.

我要测试的课程:

public class MyClass
{
    public void myMethod()
    {
        ExecutorService executorService = Executors.newFixedThreadPool(2, new MyThreadFactory());

        for (int count = 0; count < 2; count++)
        {
            executorService.submit(new Thread());
        }
    }
}

class MyThreadFactory implements ThreadFactory
{
    @Override
    public Thread newThread(Runnable r)
    {
        return null;
    }
}    

我的Test类看起来像:

@RunWith(PowerMockRunner.class)
@PrepareForTest(Executors.class)
public class MyClassTest
{
    @Test
    public void testMyMethod()
    {
        prepareMocks();            

        //Code to get mocked object (See testMethod below)
    }

    private void prepareMocks()
    {
        ExecutorService executorService = PowerMock.createMock(ExecutorService.class);
        EasyMock.expect(executorService.submit(EasyMock.anyObject(Runnable.class))).andReturn(null).anyTimes();

        PowerMock.mockStatic(Executors.class);
        EasyMock.expect(Executors.newFixedThreadPool(EasyMock.anyInt(), …

我已经看了一遍这个答案,但似乎无法找到它,所以如果这是一个愚蠢的问题,请道歉.请温柔.

我正在编写一个简单的MVC框架,我对此感到困惑SwingWorker以及如何使用它ExecutorService.

我想限制ExecutorService允许我使用的线程数Executors.newFixedThreadPool(n).

我理解使用SwingWorker的重要性,因为它有执行冗长任务的方法(doInBackground...等),并允许通过事件调度线程更改GUI.

但是,创建Executors.newFixedThreadPool(n)限制了线程的数量,n而SwingWorker似乎有某种私有内部常量设置的10个线程的限制MAX_WORKER_THREADS.

我想知道的是我咆哮错误的树试图结合这两个类来限制线程的数量,因为暗示似乎是如果我向一个SwingWorker任务提交一个任务Executor,那么一个任务会产生多达十个线程吗？

我最终的目标是编写一个程序,这将有一些密集的计算,我不想从一开始就犯这样的根本错误,因为这可能被证明是一个资源消耗问题,也就是说,我会有一个可爱的响应通过正确使用EDT进行GUI,但如果每个任务产生多达10个自己的线程,它将变得无法响应!

下面的代码检查ExecutorCompletionServicefromJava Concurrency框架的使用（正在使用的 IDE 是 Netbeans）。

但程序不会终止。为什么？

代码：

import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.Executors;

public class TestFuture {

    public static void main(String... args) throws InterruptedException, ExecutionException {
        Executor ex = Executors.newCachedThreadPool();
        CompletionService<Long> cs = new ExecutorCompletionService<Long>(ex);
        cs.submit(new Worker());
        cs.submit(new Worker());
        cs.submit(new Worker());
        for (int i = 0; i < 3; i++) {
            long l = cs.take().get();
            //utilize the result
            System.out.println(l);
        }
    }
}

class Worker implements Callable {

    @Override
    public Long …

我正在构建一个需要同时处理多个请求的 HTTPServer。

我构建的主要功能如下：

public static void main(String[] args) throws Exception {
    HttpServer server = HttpServer.create(new InetSocketAddress(8000), 0);
    server.createContext("/", new MyRequestDispatcher());

    server.setExecutor(Executors.newCachedThreadPool());
    server.start();
}

现在我正在考虑它如何Executors.newCachedThreadPool()在创建的线程数量方面发挥作用。正如我所读到的，要创建的线程数量不受限制，如果我同时收到一千个请求，它会创建一千个线程吗？

我正在考虑限制同时创建的线程数量，以便在运行它的机器中正确处理。我想到了这样的事情：

Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors())

目标是根据系统中的可用处理器仅创建给定数量的线程。

这行得通吗？

提前致谢！！

我刚刚在runnable的run()方法中编写了这段代码:

try {
    dbConnection = MyApp.datasource.getConnection();
} catch (SQLException e) {
    logger.log(Level.SEVERE, "Could not obtain a DB connection! Re-enqueuing this task. Message: " + e.getMessage(), e);
    MyApp.executor.execute(this);
    return;
}

正如您所看到的,如果任务无法获得数据库连接,它应该将自身重新入队,并进入运行之前的队列.

我认为这可能是安全的,但感觉很有趣,我只是想确保没有任何我缺少的东西.

谢谢!

我看到一种行为,我无法解释

我有一个Runnable,它的代码是:

run()
{
    print("start");
    try{
        doSomething();
        print("end");    

    }catch (Exception e){
        print("problem");
    }
    print("method end");

}

这种行为很奇怪,因为我得到的唯一打印是"开始" - 我希望得到"问题"和"方法结束"打印.如果doSomething本身处理异常 - 那么将打印"end".但除了"开始",我没有得到任何印刷品

现在我知道doSomething方法存在一些问题,好像我不是通过执行程序服务运行它,我得到"Method Not Found"异常.

我认为它可能以某种方式连接到我使用的Executor服务 - Executors.newFixedThreadPool,但我无法解释它

谢谢你的建议!

最近我得到了一个面试问题:

有一种情况,一个线程在一小时的间隔内执行批处理操作,你会使用执行框架或普通线程,为什么？

我很迷惑 .

由于只有一个线程,因此不需要执行程序服务.我可以使用while 和sleep.

while(1)
{
// do task
// t1.sleep(60*60*1000);
}

虽然有一个ScheduleExecutorService,它提供了许多方法来进行调度？

什么是最好的方法？

这是scala的代码段.我将超时设置为100毫克.在10000个循环中,其中106个循环超过100个,没有抛出异常.最大的一个甚至是135个.出现这种情况的原因是什么？

for (j <- 0 to 10000) {
  total += 1
  val executor = Executors.newSingleThreadExecutor
  val result = executor.submit[Int](new Callable[Int] {
      def call = try {
        Thread.sleep(95)
        for (i <- 0 to 1000000) {}
        4   
      } catch {
        case e: Exception => exception1 += 1
        5   
      }   
  })  

  try {
    val t1 = Calendar.getInstance.getTimeInMillis
    result.get(100, TimeUnit.MILLISECONDS)
    val t2 = Calendar.getInstance.getTimeInMillis
    println("timediff = " + (t2 - t1).toString)
  } catch {
    case e: Exception => exception2 += 1
  }   
}

在AWS Lambda中建议使用执行程序服务吗？我看到AWS文档中的进程和线程有限制

Number of processes and threads (combined total) 1,024

这是否确定我的执行程序服务中的线程数？

关闭执行程序服务对AWS lambda是否像其他进程一样重要？