Java 使用Executor处理10000个线程

我有一个web服务，20多个发送数据的服务器可以连续访问该服务。我使用过activeMQ，数据在其中排队一段时间，而不是使用异步任务来释放数据

我的异步任务线程类如下所示

public class myConsumer {

    public void  asyncConsumer() throws InterruptedException, ExecutionException{
        final MyReceiver receiver = new MyReceiver(); 

        final ExecutorService executorService = Executors.newSingleThreadExecutor();
        try{
             Future future = executorService.submit(new Runnable() {
                 public void run() {
                     receiver.receiveMessage();          
                 }
           }); 

         executorService.shutdown();
         executorService.awaitTermination(5, TimeUnit.SECONDS);

        }catch (InterruptedException e) {
            logger.error("tasks interrupted");
        }finally {
            if (!executorService.isTerminated()) {
                logger.error("cancel non-finished tasks");
            }
            executorService.shutdownNow();
        }
    }
}

---

我有10000个线程在运行。由于异常行为，我的应用程序服务器已停止。如何使用上述代码处理这么多线程。

您应该使用线程池执行器而不是单线程执行器，并确保它只是线程池接收消息的一个实例。通过这种方式，您可以跟踪并限制并发线程的数量

下面是一个如何做到这一点的例子。通过使executorservice保持静态，您可以确保它只是一个实例，并且最多可以同时执行10个线程。当您调用asyncConsumer来处理收到的消息时，将在线程池中创建并调用MyReceiver（我假设它将处理该消息）

public class MyConsumer {

    static final ExecutorService executorService = Executors.newFixedThreadPool(10);

    public void  asyncConsumer() {          
        Future future = executorService.submit(new Runnable() {
            public void run() {
               new MyReceiver().receiveMessage();          
            }
        });                  
    }
}

---

您应该使用线程池执行器而不是单线程执行器，并确保它只是接收消息的线程池的一个实例。通过这种方式，您可以跟踪并限制并发线程的数量

下面是一个如何做到这一点的例子。通过使executorservice保持静态，您可以确保它只是一个实例，并且最多可以同时执行10个线程。当您调用asyncConsumer来处理收到的消息时，将在线程池中创建并调用MyReceiver（我假设它将处理该消息）

public class MyConsumer {

    static final ExecutorService executorService = Executors.newFixedThreadPool(10);

    public void  asyncConsumer() {          
        Future future = executorService.submit(new Runnable() {
            public void run() {
               new MyReceiver().receiveMessage();          
            }
        });                  
    }
}

---

您应该使用线程池执行器而不是单线程执行器，并确保它只是接收消息的线程池的一个实例。通过这种方式，您可以跟踪并限制并发线程的数量

下面是一个如何做到这一点的例子。通过使executorservice保持静态，您可以确保它只是一个实例，并且最多可以同时执行10个线程。当您调用asyncConsumer来处理收到的消息时，将在线程池中创建并调用MyReceiver（我假设它将处理该消息）

public class MyConsumer {

    static final ExecutorService executorService = Executors.newFixedThreadPool(10);

    public void  asyncConsumer() {          
        Future future = executorService.submit(new Runnable() {
            public void run() {
               new MyReceiver().receiveMessage();          
            }
        });                  
    }
}

---

您应该使用线程池执行器而不是单线程执行器，并确保它只是接收消息的线程池的一个实例。通过这种方式，您可以跟踪并限制并发线程的数量

下面是一个如何做到这一点的例子。通过使executorservice保持静态，您可以确保它只是一个实例，并且最多可以同时执行10个线程。当您调用asyncConsumer来处理收到的消息时，将在线程池中创建并调用MyReceiver（我假设它将处理该消息）

public class MyConsumer {

    static final ExecutorService executorService = Executors.newFixedThreadPool(10);

    public void  asyncConsumer() {          
        Future future = executorService.submit(new Runnable() {
            public void run() {
               new MyReceiver().receiveMessage();          
            }
        });                  
    }
}

---

在Windows上，10000个线程相当多。试一试，为什么您要稳定地创建excutor，而不是重用一个具有负载管理且能够根据需要启动和停止线程的excutor？在Windows上，10000个线程相当多。试一试，为什么您要稳定地创建excutor，而不是重用一个具有负载管理且能够根据需要启动和停止线程的excutor？在Windows上，10000个线程相当多。试一试，为什么您要稳定地创建excutor，而不是重用一个具有负载管理且能够根据需要启动和停止线程的excutor？在Windows上，10000个线程相当多。试一试，为什么您要稳步创建excutor，而不是重用一个具有负载管理且能够根据需要启动和停止线程的excutor？添加了一个示例-它对您有意义吗？添加了一个示例-它对您有意义吗？添加了一个示例-它对您有意义吗？