java - 在 Tomcat 9 上运行的多线程服务器

Question

我试图找到一个涵盖我的问题的问题，但我只能找到很多类似的问题，但没有一个答案可以解决我的问题。

我正在为 Tomcat 创建一个 java webapp，除其他外，它还必须充当处理多个传入连接的 TCP 服务器:为此，我在单独的线程中运行 TCP 服务器代码，该线程又使用一个 ExecutorService 为每个连接创建线程。问题基本上是，当我停止 Tomcat 时，服务器线程永远不会停止(即使还没有人连接)并挂起 Tomcat，直到我在任务管理器中关闭相关进程。

所以，这是程序的起点:

private TCPServer tcpServer;
Thread serverThread;

@Override
public void init() throws ServletException {            
    DBConn = getDBConn();
    if (DBConn != null) {
        //initiates loggers, reads configurations from a file, etc

        //starts TCP server
        tcpServer = new TCPServer(50001, 200);    
        serverThread = new Thread(tcpServer);
        serverThread.start();    

        //will be doing other stuff
    } else {
        //handles DB connection failure
    }
}

这是 TCPServer 类:

public class TCPServer implements Runnable {

   private final int listeningPort;
   PrintWriter out;
   BufferedReader in;
   ServerSocket serverSocket;
   private final ExecutorService pool;

   public TCPServer(int port, int poolSize) {
       listeningPort = port;
       pool = Executors.newFixedThreadPool(poolSize);
   }    

   @Override
   public void run() {
       LinkedBlockingQueue<Socket> queue = new LinkedBlockingQueue<>();
       try {
           serverSocket = new ServerSocket(listeningPort);

           while (!Thread.currentThread().isInterrupted()) {
               pool.execute(new ConnectionHandler(queue));
               queue.put(serverSocket.accept());               
           }
       } catch (IOException | InterruptedException ex) {
           Logger.getLogger(TCPServer.class.getName()).log(Level.SEVERE, null, ex);
       }
   }

   private class ConnectionHandler implements Runnable {
       private LinkedBlockingQueue<Socket> socketQueue;
       public ConnectionHandler(LinkedBlockingQueue<Socket> queue) {
           this.socketQueue = queue;
       }

       @Override
       public void run() {
           while (!Thread.interrupted() || !Thread.currentThread().isInterrupted()) {
               try (Socket clientSocket = socketQueue.take()) {
                   in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                   String line = in.readLine();
                   System.out.println("Incoming: " + line);

                   clientSocket.close();
               } catch (InterruptedException ex) {     
              Logger.getLogger(TCPServer.class.getName()).log(Level.SEVERE,    null, ex);
               } catch (IOException ex) {   
                Logger.getLogger(TCPServer.class.getName()).log(Level.SEVERE, null, ex);
               }  
           }
       }


   public void close(){
       Thread.currentThread().interrupt();
       try {
           serverSocket.close();
       } catch (IOException ex) {  
                Logger.getLogger(TCPServer.class.getName()).log(Level.SEVERE, null, ex);           }
       pool.shutdownNow();
       }
}

我在主类(与上面的 init() 所在的位置相同)中添加了这个覆盖，它在 Tomcat 关闭时运行:

@Override
public void contextDestroyed(ServletContextEvent sce) {
    serverThread.interrupt();
    tcpServer.close();
    ServletContextListener.super.contextDestroyed(sce); 
}

为了实现我在 Internet 上找到的解决方案，我进行了如此多的编辑，其中一些代码肯定是多余的或无用的。 有人可以指点我应该如何正确停止 TCPServer 线程吗？

Answer 1

感谢this answer和 Kayaman 的评论，我修改了整个代码并以某种方式让它工作。

init() 覆盖是相同的，而 contextDestroyed 覆盖现在是

@Override
public void contextDestroyed(ServletContextEvent sce) {        
    tcpServer.close();
    serverThread.interrupt();
    ServletContextListener.super.contextDestroyed(sce);
}

现在的 TCPServer 类是:

public class TCPServer implements Runnable {
   private final int listeningPort;
   PrintWriter out;
   BufferedReader in;
   ServerSocket serverSocket;
   private final ExecutorService pool;

   public TCPServer(int port, int poolSize) {
       listeningPort = port;
       pool = Executors.newFixedThreadPool(poolSize);
   }    

   @Override
   public void run() {
       try {
           serverSocket = new ServerSocket(listeningPort);

           while (!Thread.currentThread().isInterrupted()) {    
               Socket clientSocket = serverSocket.accept();
               pool.submit(new ConnectionHandler(clientSocket)); 
           }

       } catch (IOException ex) {
           Logger.getLogger(TCPServer.class.getName()).log(Level.SEVERE, null, ex);
       } finally {
           pool.shutdown();
       }
   }

   private class ConnectionHandler implements Runnable {
        private Socket sock;

       public ConnectionHandler(Socket sock){
           this.sock = sock;
       }

       @Override
       public void run() {
           while (!Thread.currentThread().isInterrupted()) {
               try{
                   in = new BufferedReader(new InputStreamReader(sock.getInputStream()));
                   String line = in.readLine();
                   System.out.println("Incoming: " + line);

                   sock.close();

                  } catch (IOException ex) { 
                      Logger.getLogger(TCPServer.class.getName()).log(Level.SEVERE, null, ex);
                  }   
              }
          }
      }

   public void close(){        
       try {
           serverSocket.close();
       } catch (IOException ex) {
           Logger.getLogger(TCPServer.class.getName()).log(Level.SEVERE, null, ex);
       }
   }
}