Как сделать так, чтобы Java приложение перестало работать

Как сделать так, чтобы Java приложение перестало работать

Этот вопрос трактуется двояко: либо грациозное завершение приложения, либо критические ошибки, приводящие к аварийному выходу. Оба сценария важны понимать при разработке production-приложений.

1. Грациозное завершение (Graceful Shutdown)

1.1. System.exit()

Самый прямой способ прекратить работу JVM:

public class Application {
    public static void main(String[] args) {
        System.out.println("Starting application...");
        
        try {
            // Основная логика
            runApplication();
        } catch (Exception ex) {
            System.err.println("Fatal error: " + ex.getMessage());
            System.exit(1); // Завершить с кодом ошибки
        }
        
        System.exit(0); // Завершить успешно
    }
    
    private static void runApplication() {
        // Логика приложения
    }
}

// Коды выхода (соглашение):
// 0 — успешное завершение
// 1-255 — различные ошибки
// Используй 1 для generic ошибки, 2 для ошибок запуска и т.д.

1.2. Shutdown Hook для очистки ресурсов

Чтобы освободить ресурсы перед выходом:

public class Application {
    private static DatabaseConnection dbConnection;
    private static ThreadPoolExecutor executor;
    
    public static void main(String[] args) {
        // Регистрируем shutdown hook
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            System.out.println("\nApplication shutting down...");
            cleanup();
        }));
        
        try {
            startup();
            runApplication();
        } catch (Exception ex) {
            System.err.println("Fatal error: " + ex.getMessage());
            System.exit(1);
        }
    }
    
    private static void startup() {
        dbConnection = new DatabaseConnection();
        dbConnection.connect();
        executor = new ThreadPoolExecutor(
            10, 20, 60, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>()
        );
    }
    
    private static void cleanup() {
        // Закрываем все ресурсы
        if (dbConnection != null) {
            dbConnection.close();
        }
        if (executor != null) {
            executor.shutdown();
            try {
                // Ждём завершения текущих задач (максимум 30 сек)
                if (!executor.awaitTermination(30, TimeUnit.SECONDS)) {
                    executor.shutdownNow(); // Принудительно завершить
                }
            } catch (InterruptedException ex) {
                executor.shutdownNow();
            }
        }
        System.out.println("Cleanup completed");
    }
    
    private static void runApplication() {
        // Основная логика
    }
}

1.3. Shutdown Hook в Spring Boot

@SpringBootApplication
public class SpringApplication {
    
    public static void main(String[] args) {
        var app = new SpringApplication(SpringApplication.class);
        app.run(args);
    }
}

// Spring автоматически управляет shutdown hooks
// Но можешь добавить свои:

@Component
public class GracefulShutdownManager {
    
    private static final Logger log = LoggerFactory.getLogger(
        GracefulShutdownManager.class
    );
    
    @EventListener(ContextClosedEvent.class)
    public void onShutdown(ContextClosedEvent event) {
        log.info("Application is shutting down");
        // Очистка ресурсов
        cleanup();
    }
    
    private void cleanup() {
        // Закрытие БД, пулов потоков и т.д.
    }
}

2. Критические ошибки (приводящие к завершению)

2.1. OutOfMemoryError

Одна из самых опасных ошибок — нехватка памяти:

public class MemoryTest {
    public static void main(String[] args) {
        List<byte[]> memory = new ArrayList<>();
        
        try {
            // Бесконечно выделяем память
            for (int i = 0; i < Integer.MAX_VALUE; i++) {
                memory.add(new byte[1024 * 1024]); // 1 MB за раз
                if (i % 100 == 0) {
                    System.out.println("Allocated " + i + " MB");
                }
            }
        } catch (OutOfMemoryError ex) {
            System.err.println("Out of memory: " + ex.getMessage());
            // JVM может завершиться после этого
            System.exit(1);
        }
    }
}

// Результат: java.lang.OutOfMemoryError: Java heap space

2.2. StackOverflowError

Бесконечная рекурсия приводит к переполнению стека:

public class StackOverflowTest {
    
    public static void recursiveMethod() {
        recursiveMethod(); // Вызывает сам себя без выхода
    }
    
    public static void main(String[] args) {
        try {
            recursiveMethod();
        } catch (StackOverflowError ex) {
            System.err.println("Stack overflow: " + ex.getMessage());
            System.exit(1);
        }
    }
}

// Результат: java.lang.StackOverflowError

2.3. Thread.currentThread().stop() (deprecated)

public class StopThreadExample {
    public static void main(String[] args) throws InterruptedException {
        Thread worker = new Thread(() -> {
            try {
                while (true) {
                    System.out.println("Working...");
                    Thread.sleep(1000);
                }
            } catch (InterruptedException ex) {
                Thread.currentThread().interrupt();
            }
        });
        
        worker.start();
        Thread.sleep(5000);
        
        // DEPRECATED и ОПАСНО! Используй interrupt вместо этого
        // worker.stop();
        
        // ПРАВИЛЬНО: прерываем поток
        worker.interrupt();
        worker.join(5000);
    }
}

2.4. Правильный способ завершить поток

public class GracefulThreadShutdown {
    
    private volatile boolean running = true;
    
    public void startWorker() {
        Thread worker = new Thread(() -> {
            while (running) {
                try {
                    // Выполняем работу
                    doWork();
                    Thread.sleep(1000);
                } catch (InterruptedException ex) {
                    System.out.println("Worker interrupted");
                    break;
                }
            }
            cleanup();
            System.out.println("Worker finished");
        });
        
        worker.start();
    }
    
    public void stopWorker() {
        running = false;
    }
    
    private void doWork() {
        System.out.println("Doing work...");
    }
    
    private void cleanup() {
        System.out.println("Cleaning up resources");
    }
}

3. Завершение Spring Boot приложения

@RestController
@RequestMapping("/api")
public class ShutdownController {
    
    private static final Logger log = LoggerFactory.getLogger(
        ShutdownController.class
    );
    
    private final ApplicationContext applicationContext;
    
    public ShutdownController(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }
    
    @PostMapping("/shutdown")
    public ResponseEntity<?> shutdown() {
        // Выполняем грациозное завершение
        new Thread(() -> {
            log.info("Shutdown request received");
            SpringApplication.exit(
                applicationContext,
                () -> 0
            );
        }).start();
        
        return ResponseEntity.ok("Shutting down");
    }
}

4. Завершение приложения в контексте контейнеризации

В Docker/Kubernetes приложение должно корректно обрабатывать SIGTERM:

public class ContainerAwareApplication {
    
    public static void main(String[] args) {
        // Обработка SIGTERM сигнала (graceful shutdown)
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            System.out.println("SIGTERM received, shutting down...");
            // Очистка
        }));
        
        // Запуск Spring Boot
        SpringApplication.run(ContainerAwareApplication.class, args);
    }
}

5. Сравнение методов завершения

6. Лучшие практики

public class BestPractices {
    
    // ПРАВИЛЬНО: грациозное завершение
    private static void gracefulShutdown() {
        // 1. Прекращаем принимать новые запросы
        stopAcceptingRequests();
        
        // 2. Даём время завершить текущие операции
        waitForActiveRequests(30, TimeUnit.SECONDS);
        
        // 3. Закрываем ресурсы
        closeResources();
        
        // 4. Выходим
        System.exit(0);
    }
    
    // НЕПРАВИЛЬНО: грубое завершение
    private static void badShutdown() {
        // Просто выход, без очистки
        System.exit(0); // Может потеряться данные!
    }
}

Итоги

Завершение Java приложения может быть:

1. Грациозным (правильно):

   • Shutdown hooks для очистки
   • Прерывание потоков через interrupt()
   • Ожидание завершения текущих операций
   • Закрытие всех ресурсов

2. Аварийным (плохо):

   • System.exit() без cleanup
   • StackOverflowError или OutOfMemoryError
   • Thread.stop() (deprecated)
   • Потеря данных и утечки ресурсов

Золотое правило: всегда реализуй graceful shutdown, особенно в production — это определяет надёжность приложения и возможность безболезненного развёртывания обновлений.