Java 使用ExecutorService并行处理任务

我正在编写一个java程序，它需要并行监视多台机器。这个数字不是固定的，它可以在程序执行期间的任何时候变化（增加/减少）

我想做这样的事情：

public static void main (String args[]) {

    ExecutorService EXEC1 = Executors.newScheduledThreadPool(1);

    EXEC1.scheduleWithFixedDelay(new Runnable() {

        ExecutorService EXEC2 = Executors.new...
        Map<Integer, Future<Void>> monitoringTasks = new HashMap<Integer, Future<Void>>();

        @Override
        public void run() {

            List<Machine> monitorizedMachines = MachineDao.getMonitorizedMachines();

            for (Machine machine: monitorizedMachines) {

                Future<Void> monitoringTask = monitoringTasks.get(machine.getId());

                if(monitoringTask == null || monitoringTask.isDone()) {

                    monitoringTask = EXEC2.submit(new Runnable() {
                        @Override
                        public void run() throws Exception {

                            // monitor machine....

                        }
                    });

                    monitoringTasks.put(machine.getId(), monitoringTask);
                }

            }
        }

    }, 1, 1, TimeUnit.SECONDS);

}

publicstaticvoidmain（字符串参数[]）{
ExecutorService EXEC1=Executors.newScheduledThreadPool（1）；
EXEC1.scheduleWithFixedDelay（新的可运行（）{
ExecutorService EXEC2=执行者。新建。。。
Map monitoringTasks=新建HashMap（）；
@凌驾
公开募捐{
List monitorizedMachines=MachineDao.getMonitorizedMachines（）；
用于（机器：监控机器）{
Future monitoringTask=monitoringTasks.get（machine.getId（））；
if（monitoringTask==null | | monitoringTask.isDone（））{
monitoringTask=EXEC2.submit（新的Runnable（）{
@凌驾
public void run（）引发异常{
//监控机器。。。。
}
});
monitoringTasks.put（machine.getId（），monitoringTask）；
}
}
}
}，1，1，时间单位为秒）；
}

但是我很难为这种情况选择最合适的执行器（EXEC2）：FixedThreadPool、CachedThreadPool、自定义实现

需要说明的是，每个监控任务大约有2/3秒长

---

有人能给我一些建议吗？

大多数时候，当您开发基于生产的大型应用程序时，您需要使用

ExecutorService EXEC2=Executors.newFixedThreadPool（线程计数）

并且在执行性能测试后，您需要正确配置

线程计数

，使用预期的请求数/卷数

---

您可以查看更多详细信息，了解为什么

newCachedThreadPool（）

不适合具有大量请求的应用程序。

大多数时候，在开发基于生产的大型应用程序时，您需要使用

executservice EXEC2=Executors.newFixedThreadPool（线程计数）

并且在执行性能测试后，您需要正确配置

线程计数

，使用预期的请求数/卷数

---

您可以查看更多详细信息，了解为什么

newCachedThreadPool（）

不适合具有大量请求的应用程序。

这是一个简单的示例。 首先在您的类机器中添加一个公共变量boolean正在工作的示例。在run（）代码中，在变量之间添加代码，如下例所示：

public static class Machine implements Runnable {

        public boolean ISWORKING = true;

        @Override
        public void run() {
            this.ISWORKING = true;
            //YOUR CODE HERE..................
            this.ISWORKING = false;
        }

    }

第二个示例代码：

    Timer timer = null;
    TimerTask task = null;
    boolean isLocked = false;

    public void main() {

        task = new TimerTask() {

            @Override
            public void run() {

                if (isLocked) {
                    return;
                }

                isLocked = true;

                List<Machine> monitorizedMachines = MachineDao.getMonitorizedMachines();

                //Count the pending job.
                int poolsize = 0;
                for (Machine machine : monitorizedMachines) {

                    if (!machine.ISWORKING) {
                        poolsize++;
                    }

                }

                if (poolsize == 0) {
                    isLocked = false;
                    return;
                }

                //Prevent a lot of poolsize.
                poolsize = Math.min(100, poolsize);

                ThreadPoolExecutor pool = (ThreadPoolExecutor) Executors.newFixedThreadPool(poolsize);

                for (Machine machine : monitorizedMachines) {

                    if (!machine.ISWORKING) {
                        pool.execute(machine);
                    }

                }
                pool.shutdown();


                isLocked = false;

            }

        };

        timer = new Timer();
        timer.schedule(task, 1000, 2000);

    }

Timer=null；
TimerTask任务=null；
布尔值isLocked=false；
公共图书馆{
任务=新时间任务（）{
@凌驾
公开募捐{
如果（已锁定）{
返回；
}
isLocked=true；
List monitorizedMachines=MachineDao.getMonitorizedMachines（）；
//计算挂起的作业。
int poolsize=0；
用于（机器：监控机器）{
如果（！machine.ISWORKING）{
池大小++；
}
}
如果（池大小==0）{
isLocked=false；
返回；
}
//防止池大小过大。
poolsize=Math.min（100，poolsize）；
ThreadPoolExecutor pool=（ThreadPoolExecutor）Executors.newFixedThreadPool（poolsize）；
用于（机器：监控机器）{
如果（！machine.ISWORKING）{
pool.execute（机器）；
}
}
pool.shutdown（）；
isLocked=false；
}
};
定时器=新定时器（）；
时间表（任务，10002000）；
}

这是一个简单的示例。 首先在您的类机器中添加一个公共变量boolean正在工作的示例。在run（）代码中，在变量之间添加代码，如下例所示：

public static class Machine implements Runnable {

        public boolean ISWORKING = true;

        @Override
        public void run() {
            this.ISWORKING = true;
            //YOUR CODE HERE..................
            this.ISWORKING = false;
        }

    }

第二个示例代码：

    Timer timer = null;
    TimerTask task = null;
    boolean isLocked = false;

    public void main() {

        task = new TimerTask() {

            @Override
            public void run() {

                if (isLocked) {
                    return;
                }

                isLocked = true;

                List<Machine> monitorizedMachines = MachineDao.getMonitorizedMachines();

                //Count the pending job.
                int poolsize = 0;
                for (Machine machine : monitorizedMachines) {

                    if (!machine.ISWORKING) {
                        poolsize++;
                    }

                }

                if (poolsize == 0) {
                    isLocked = false;
                    return;
                }

                //Prevent a lot of poolsize.
                poolsize = Math.min(100, poolsize);

                ThreadPoolExecutor pool = (ThreadPoolExecutor) Executors.newFixedThreadPool(poolsize);

                for (Machine machine : monitorizedMachines) {

                    if (!machine.ISWORKING) {
                        pool.execute(machine);
                    }

                }
                pool.shutdown();


                isLocked = false;

            }

        };

        timer = new Timer();
        timer.schedule(task, 1000, 2000);

    }

Timer=null；
TimerTask任务=null；
布尔值isLocked=false；
公共图书馆{
任务=新时间任务（）{
@凌驾
公开募捐{
如果（已锁定）{
返回；
}
isLocked=true；
List monitorizedMachines=MachineDao.getMonitorizedMachines（）；
//计算挂起的作业。
int poolsize=0；
用于（机器：监控机器）{
如果（！machine.ISWORKING）{
池大小++；
}
}
如果（池大小==0）{
isLocked=false；
返回；
}
//防止池大小过大。
poolsize=Math.min（100，poolsize）；
ThreadPoolExecutor pool=（ThreadPoolExecutor）Executors.newFixedThreadPool（poolsize）；
用于（机器：监控机器）{
如果（！machine.ISWORKING）{
pool.execute（机器）；
}
}
pool.shutdown（）；
isLocked=false；
}
};
定时器=新定时器（）；
时间表（任务，10002000）；
}

我有个主意，我需要你的课堂机器中的代码我有个主意，我需要你的课堂机器中的代码