重新部署Java Web应用反复抛出java.net.BindException，需重启服务器

嘿，这个问题我之前也踩过坑！本质上是你重新部署应用时，旧实例的监听线程或者ServerSocket没被彻底清理干净，导致端口还被占用着，新实例自然绑不上了。咱们一步步来搞定它：

核心问题分析 #

你的代码里虽然用了try-with-resources来关闭ServerSocket，但有两个关键漏洞：

1. Web应用销毁时，你的work变量可能没被及时感知到，或者线程卡在serverSocket.accept()的阻塞调用里，根本跳不出循环，导致ServerSocket一直没机会关闭。
2. 就算ServerSocket关闭了，操作系统可能会把端口保留在TIME_WAIT状态一段时间，这时候新实例也没法绑定同一个端口。

具体解决方案 #

1. 在上下文销毁时主动终止监听线程 #

Web应用重新部署时，容器会调用ServletContextListener的contextDestroyed方法，你得在这里手动停止监听线程，还要中断它的阻塞调用：

首先，在监听器里保存监听线程的引用：

public class AppContextListener implements ServletContextListener {
    private SocketThread socketListenerThread;

    @Override
    public void contextInitialized(ServletContextEvent event) {
        // 初始化你的conf、bpk等参数
        socketListenerThread = new SocketThread(conf, bpk);
        socketListenerThread.start();
    }

    @Override
    public void contextDestroyed(ServletContextEvent event) {
        // 标记线程停止
        socketListenerThread.stopRunning();
        // 中断阻塞的accept()调用
        socketListenerThread.interrupt();
        // 等待线程完全终止，避免残留
        try {
            socketListenerThread.join();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

2. 修改SocketThread，处理中断并启用端口重用 #

调整ServerSocket的创建逻辑，启用SO_REUSEADDR选项，同时用volatile保证work变量的多线程可见性：

public class SocketThread extends Thread {
    private volatile boolean work = true; // volatile确保状态变化立刻被感知
    private ServerSocket serverSocket;
    private final Config conf;
    private final Bpk bpk;

    public SocketThread(Config conf, Bpk bpk) {
        this.conf = conf;
        this.bpk = bpk;
    }

    @Override
    public void run() {
        int port = Integer.parseInt(conf.getConf("port"));
        try {
            // 先创建未绑定的ServerSocket，设置重用选项
            serverSocket = new ServerSocket();
            serverSocket.setReuseAddress(true); // 关键：允许端口快速重用
            serverSocket.bind(new InetSocketAddress(port));

            while (work) {
                try {
                    Socket socket = serverSocket.accept();
                    System.out.println("User connected!");
                    WorkThread workThread = new WorkThread(conf, socket, bpk);
                    workThread.start();
                } catch (SocketException e) {
                    // 线程被中断时，accept()会抛出这个异常，判断是主动停止还是异常
                    if (!work) {
                        System.out.println("监听线程正在停止...");
                    } else {
                        throw e; // 真正的异常才抛出
                    }
                }
            }
        } catch (IOException ex) {
            Logger.getLogger(SocketThread.class.getName()).log(Level.SEVERE, null, ex);
        } finally {
            // 确保ServerSocket被关闭
            if (serverSocket != null && !serverSocket.isClosed()) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public void stopRunning() {
        this.work = false;
    }
}

3. 关键细节解释 #

• volatile修饰work：保证当contextDestroyed里设置work=false时，监听线程能立刻看到这个变化，不会一直死循环。
• setReuseAddress(true)：解决TIME_WAIT状态的端口占用问题，让操作系统允许新的应用实例绑定同一个端口，不用等TIME_WAIT超时。
• 中断线程：serverSocket.accept()是阻塞调用，仅仅设置work=false不会让它退出，必须调用interrupt()让它抛出SocketException，才能跳出循环执行后续的关闭逻辑。
• 等待线程终止：join()方法确保旧的监听线程完全停止后，再完成应用销毁，避免新旧实例争抢端口。

额外排查技巧 #

如果还是有问题，可以用系统命令查看端口占用：

• Linux/macOS：lsof -i :<你的端口号> 或者 netstat -tulpn | grep <端口号>
• Windows：netstat -ano | findstr :<你的端口号>

看看是不是还有旧的Java进程在占用端口，如果有，手动杀掉再试。

内容的提问来源于stack exchange，提问作者faleksic