quarkusio/quarkus · warning · RuntimeException

java.lang.InterruptedException (wrapped)

Error message

java.lang.InterruptedException (wrapped)

What it means

RuntimeUpdatesProcessor.handleChanges(), when running in test mode, sleeps 500ms before periodic test compilation; if that Thread.sleep is interrupted, the InterruptedException is wrapped in a RuntimeException and rethrown. The interruption typically comes from dev mode shutting down while change handling is in flight, so this is usually a benign shutdown-time failure.

Source

Thrown at core/deployment/src/main/java/io/quarkus/deployment/dev/RuntimeUpdatesProcessor.java:253

                if (IS_LINUX) {
                    //note that this is only used for notifications that something has changed,
                    //this triggers the same file scan as the polling approach
                    //this is not as efficient as it could be, but saves having two separate code paths
                    testClassChangeWatcher = new WatchServiceFileSystemWatcher("Quarkus Test Watcher", true);
                    FileChangeCallback callback = new FileChangeCallback() {
                        @Override
                        public void handleChanges(Collection<FileChangeEvent> changes) {
                            //sometimes changes come through as two events
                            //which can cause problems for our CI tests
                            //and cause unnecessary runs.
                            //we add a half second delay for CI tests, to make sure this does not cause
                            //problems
                            try {
                                if (context.isTest()) {
                                    Thread.sleep(500);
                                }
                            } catch (InterruptedException e) {
                                throw new RuntimeException(e);
                            }
                            periodicTestCompile();
                        }
                    };
                    // monitor .env as it can impact test execution
                    testClassChangeWatcher.watchFiles(Path.of(context.getApplicationRoot().getProjectDirectory()),
                            List.of(Path.of(".env")),
                            callback);
                    Set<Path> nonExistent = new HashSet<>();
                    for (DevModeContext.ModuleInfo module : context.getAllModules()) {
                        for (Path path : module.getMain().getSourcePaths()) {
                            testClassChangeWatcher.watchDirectoryRecursively(path, callback);
                        }
                        for (Path path : module.getMain().getResourcePaths()) {
                            testClassChangeWatcher.watchDirectoryRecursively(path, callback);
                        }
                    }
                    for (DevModeContext.ModuleInfo module : context.getAllModules()) {

View on GitHub (pinned to e1c734241f)

Solutions

  1. Usually ignore: it occurs during shutdown and does not affect a fresh dev mode run.
  2. If it appears repeatedly at runtime, check which component interrupts the update thread (e.g. executor shutdown) and ensure change watchers are stopped before shutdown.
  3. Upgrade Quarkus — later releases handle interruption in the update loop more gracefully.
  4. Reproduce context: note whether it coincides with test completion; adjust quarkus.test.continuous-testing settings if disruptive.

Example fix

// before (framework behavior on shutdown)
Thread.sleep(500); // InterruptedException -> RuntimeException

// after (user-side): nothing to change in app code; restart dev mode cleanly
./mvnw quarkus:dev
Defensive patterns

Strategy: try-catch

Try / catch

try {
    // change handling / shutdown
} catch (RuntimeException e) {
    if (e.getCause() instanceof InterruptedException) {
        Thread.currentThread().interrupt(); // expected during shutdown; treat as benign
    }
}

Prevention

When it happens

Trigger: Dev mode / continuous testing stops (application shutdown, watcher thread interrupted) at the exact moment handleChanges is sleeping before periodicTestCompile(); the InterruptedException is converted to a RuntimeException.

Common situations: Stopping quarkus:dev (Ctrl+C) while continuous testing is mid-recompile; test run finished and the update processor being torn down during a change event.

Related errors

AI-assisted analysis of quarkusio/quarkus@e1c734241f (2026-09-05). Data as JSON: /api/errors/491fb284efc661d1. Report an issue: GitHub.