Fix AXIS2-5696: Prevent ThreadPool thread leaks by enabling core thread timeout

Enable allowCoreThreadTimeOut(true) on the ThreadPoolExecutor, which was
commented out with a JDK 1.6 FIXME that is long obsolete. Idle core threads
now terminate after the 10-second keepAlive period instead of persisting
indefinitely. Also shut down the ThreadPool in ConfigurationContext.terminate()
as defense-in-depth.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: robertlazarski

modules/kernel/src/org/apache/axis2/context/ConfigurationContext.java

@@ -737,6 +737,10 @@ public void shutdownModulesAndServices() throws AxisFault{
      */
     public void terminate() throws AxisFault {
         shutdownModulesAndServices();
+        // AXIS2-5696: Shut down the thread pool to prevent thread leaks
+        if (threadPool instanceof ThreadPool) {
+            ((ThreadPool) threadPool).safeShutDown();
+        }
         if (listenerManager != null) {
             listenerManager.destroy();
         }

modules/kernel/src/org/apache/axis2/util/threadpool/ThreadPool.java

@@ -114,8 +114,7 @@ TimeUnit.SECONDS, new SynchronousQueue(),
                     TimeUnit.SECONDS, new LinkedBlockingQueue(),
                     new DefaultThreadFactory(name, daemon, priority));
         }
-// FIXME: This API is only in JDK 1.6 - Use reflection?        
-//        rc.allowCoreThreadTimeOut(true);
+        rc.allowCoreThreadTimeOut(true);
         return rc;
     }
 

modules/kernel/test/org/apache/axis2/util/threadpool/TestThreadPool.java

@@ -24,6 +24,8 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
 
 public class TestThreadPool extends AbstractTestCase {
     /**
@@ -46,7 +48,7 @@ public boolean isWorkDone() {
     }
 
 
-    public void testPool() throws AxisFault {
+    public void testPool() throws Exception {
         ThreadPool tPool = new ThreadPool();
         List workerList = new ArrayList();
 
@@ -57,11 +59,43 @@ public void testPool() throws AxisFault {
         }
 
         tPool.safeShutDown();
+        ThreadPoolExecutor executor = (ThreadPoolExecutor) tPool.getExecutor();
+        executor.awaitTermination(5, TimeUnit.SECONDS);
 
         for (int i = 0; i < 5; i++) {
             assertEquals(true, ((TestWorker) workerList.get(i)).isWorkDone());
         }
 
     }
 
+    /**
+     * Test that core threads time out and terminate after the keepAlive period
+     * when allowCoreThreadTimeOut is enabled (AXIS2-5696).
+     */
+    public void testCoreThreadsTimeOut() throws Exception {
+        ThreadPool tPool = new ThreadPool();
+        ThreadPoolExecutor executor = (ThreadPoolExecutor) tPool.getExecutor();
+
+        // Verify allowCoreThreadTimeOut is enabled
+        assertTrue("allowCoreThreadTimeOut should be enabled",
+                executor.allowsCoreThreadTimeOut());
+
+        // Submit a task directly to the executor to create a core thread
+        TestWorker worker = new TestWorker();
+        executor.execute(worker);
+
+        // Wait briefly for the task to complete and the thread to be created
+        Thread.sleep(500);
+        assertTrue("Worker should have completed", worker.isWorkDone());
+        assertTrue("Pool should have at least one thread",
+                executor.getPoolSize() > 0);
+
+        // Wait for keepAlive timeout (10 seconds) plus buffer
+        Thread.sleep(12_000);
+
+        // Core threads should have timed out and terminated
+        assertEquals("All core threads should have timed out", 0,
+                executor.getPoolSize());
+    }
+
 }