ColdFusion 2025 Language Enhancements

5. Thread Functionality Enhancements

With JDK 21 no longer supporting thread stopping, ColdFusion 2025 implements graceful thread termination via interrupts:

cfml

<cfscript>

  // Implementing a data processing task with graceful interruption

  

  // Create a log function to track thread activities with timestamps

  function logActivity(message) {

    writeOutput("#timeFormat(now(), 'HH:mm:ss.SSS')# - #message#<br>");

  }

  

  // Initialize processing parameters

  batchSize = 50;

  maxProcessingTime = 10000; // 10 seconds 

  threadName = "dataProcessor_#createUUID()#";

  

  // Start the batch processing thread

  logActivity("Starting batch processing thread (#threadName#)");

  

  thread action="run" name="#threadName#" {

    // Variables for this thread

    local.processedRecords = 0;

    local.startTime = getTickCount();

    local.errorCount = 0;

    

    try {

      // Processing loop with interrupt checking

      while(!isThreadInterrupted(threadName)) {

        // Simulate batch processing work

        for (local.i = 1; local.i <= batchSize; local.i++) {

          // Check for interrupt at batch item level for responsiveness

          if (isThreadInterrupted(threadName)) {

            thread.interruptedDuringBatch = true;

            break;

          }

          

          // Simulate processing a record (with occasional errors)

          try {

            // Simulate work

            sleep(25); // 25ms per record

            

            // Simulate occasional failure

            if (randRange(1, 100) > 95) {

              throw(type="ProcessingException", message="Simulated processing error");

            }

            

            // Record processed successfully

            local.processedRecords++;

          }

          catch (any e) {

            local.errorCount++;

            writeOutput("Error processing record: #e.message#<br>");

            // Continue processing despite errors

          }

        }

        

        // Update status after each batch

        thread.status = {

          "processedRecords": local.processedRecords,

          "errorCount": local.errorCount,

          "elapsedTime": getTickCount() - local.startTime,

          "lastBatchTime": now()

        };

        

        // Check if we've exceeded our max processing time

        if (getTickCount() - local.startTime > maxProcessingTime) {

          writeOutput("Maximum processing time reached. Self-interrupting.<br>");

          interruptThread(threadName);

        }

        

        // Yield briefly to allow other processes to run

        sleep(10);

      }

    }

    catch (any e) {

      // Handle unexpected errors

      writeOutput("Thread encountered an error: #e.message#<br>");

      thread.fatalError = e;

    }

    finally {

      // Always perform cleanup operations when thread ends

      thread.finalStatistics = {

        "totalRecords": local.processedRecords,

        "totalErrors": local.errorCount,

        "totalTime": getTickCount() - local.startTime,

        "averageRecordTime": (local.processedRecords > 0) ? 

                            (getTickCount() - local.startTime) / local.processedRecords : 0,

        "completionTime": now()

      };

      

      writeOutput("Thread #threadName# is exiting gracefully after processing #local.processedRecords# records.<br>");

      writeOutput("Cleanup operations completed successfully.<br>");

    }

  }

  

  // Let the thread start and process some data

  sleep(2000);

  

  // Check thread status

  logActivity("Thread status after 2 seconds: #evaluate(threadName).STATUS#");

  

  // Interrupt the thread

  logActivity("Sending interrupt signal to thread");

  interruptThread(threadName);

  

  logActivity("Interrupt signal sent. Thread interrupted status: #isThreadInterrupted(threadName)#");

  

  // Wait for the thread to complete with a timeout

  thread action="join" name="#threadName#" timeout="5000" {

    logActivity("Thread join operation completed");

  }

  

  // Display final thread information

  logActivity("Final thread status: #evaluate(threadName).STATUS#");

  

  // If available, show the thread's statistics

  if (structKeyExists(evaluate(threadName), "finalStatistics")) {

    finalStats = evaluate(threadName).finalStatistics;

    writeOutput("<h4>Processing Summary:</h4>");

    writeOutput("<ul>");

    writeOutput("<li>Records processed: #finalStats.totalRecords#</li>");

    writeOutput("<li>Errors encountered: #finalStats.totalErrors#</li>");

    writeOutput("<li>Total processing time: #finalStats.totalTime# ms</li>");

    writeOutput("<li>Average time per record: #numberFormat(finalStats.averageRecordTime, '999.99')# ms</li>");

    writeOutput("</ul>");

  }

</cfscript>

This example demonstrates how to implement interruptible threads in ColdFusion 2025, featuring:

• Graceful interrupt handling with proper cleanup
• Status tracking and reporting
• Error handling that preserves thread stability
• Self-monitoring for timeout conditions
• Structured final statistics reporting