如何每秒执行数以万计的异步操作，每个操作都有三秒的等待时间？

Question

我需要在一个应用程序中每秒执行数以万计的 IO 绑定操作，每个操作都有 3 秒的延迟。 在 node.js 中，这可以简单地完成如下：

var events = require('events');
var eventEmitter = new events.EventEmitter();

var count = 0;

var connectHandler = function connected() {
    setTimeout(function() {
        count++;
        console.log('task complete ' + count);
    }, 3000);
}

for (var i = 0; i < 30000; i++) {
    eventEmitter.on('mockedIOTask', connectHandler);
}

eventEmitter.emit('mockedIOTask');

这如何在 Java 应用程序中完成？ 我尝试了以下操作，但它一次只执行 3 个任务（出于显而易见的原因）：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ForkJoinPool;

public class Main {
    public static void main(String[] args) {
        //ExecutorService threadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 30000; i++) {
            final int count = i;
            ForkJoinPool.commonPool().submit(() -> {
                try {
                    Thread.sleep(3000);
                    System.out.println("task complete" + count);
                } catch (InterruptedException e) {
                }
            });
        }
        // Keep the program alive
        try {
            Thread.sleep(50000);
        } catch (InterruptedException e) {
        }
    }
} 

Answer 1

您可以在 3 秒后使用 ScheduledExecutorService 执行 30K 任务

ScheduledExecutorService ses = Executors.newSingleThreadScheduledExecutor();
List<Future<?>> tasks = new ArrayList<>();
for (int i = 0; i < 30000; i++) {
    final int count = i;
    tasks.add(ses.submit(() -> System.out.println("task complete" + count)));
}
for (Future f : tasks) f.get();
ses.shutdown();

如果你想添加 IO 绑定操作，我会从阻塞操作开始，然后迁移到使用像 netty 这样的库来处理非阻塞 IO。