CFThread Must Die (Kill Bill) - Part 2

In Part 1 I mentioned the internal CF class coldfusion.thread.Task that seems to be used for running processes with cfthread. Tasks for a given thread can be retrieved from the FusionContext class using a method called getUserThreadTask(). So between the two, you should have enough information for makings of an experimental tracker.

Now I was particularly interested in the coldfusion.thread.Task's cancel() method and whether it could be used to kill a cfthread programatically. So I created a very simple cfthread. The thread itself does very little besides outputting a few messages. But I added a few sleep statements to simulate a thread that would take twenty (20) seconds to execute.

<cfset threadName = "CFZombieThread_Test" >

<!--- Start the new thread ---->
<cfthread action="run" name="#threadName#" myName="#threadName#">
<cfset var zombieThreadName = getPageContext().getFusionContext().getCurrentUserThreadName() />

<cfloop from="1" to="20" index="counter">

 <cfoutput>
 Mindless groan from zombie thread #zombieThreadName# at #now()# ...<br/>
 </cfoutput>
 <!---
     Force the thread to sleep to simulate a long running task
 --->     
 <cfset sleep(1 * 1000) />

</cfloop>

</cfthread>

Next, I used the ever handy getPageContext() function to grab the FusionContext. I am not extremely familiar with this class. But from what I have learned, it provides executing requests with access to context-sensitive information like session variables, application settings, etcetera. After grabbing the context, I called the getUserThreadTask() method to retrieve the Task associated with my newly created thread.

Note: When using this method be sure to convert the thread name to upper case. I discovered through trial and error that the thread names are stored in some type of case sensitive structure, and all the keys are in upper case. So if you use mixed, or lower case, the method will not be able to locate your thread.

<cfset context = getPageContext().getFusionContext() />
<cfset task = context.getUserThreadTask(UCASE(threadName)) />
<cfdump var="#cfthread[threadName]#" label="#threadName# BEFORE cancel() request " />

Next, I forced the current page to take a brief nap, to give my thread a chance to produce some output and prove it was running. Finally, I used the Task's cancel() method to kill the thread. Then forced the parent page to sleep again before checking the thread's final status. Just to give the thread a chance to catch its breath.

<!--- Sleep for a few seconds to give the thread a chance to produce some output ...--->
<cfset createObject("java", "java.lang.Thread").currentThread().sleep(2000) />

<!--- Now, try and kill the thread --->
<cfset task.cancel() />

<!--- Finally, give the thread a chance to catch up before we check its final status ...--->
<cfset createObject("java", "java.lang.Thread").currentThread().sleep(500) />
<cfdump var="#cfthread[threadName]#" label="#threadName# AFTER cancel() request " />

As you can see, the thread was successfully terminated.



The next step was storing the thread information in a shared scope. So it could be accessed as needed. Now I know there are a few ways you could approach it and different scopes you could use. But for the sake of simplicity, I decided to have the threads add and remove themselves from a tracker object stored the application scope. It is obviously not as elegant as a built in monitor, and could definitely use improvement. But it was good enough for some simple tests.

 <!--- Start the new thread ---->
 <cfthread action="run" name="#newThreadName#" >
      
         <cfset var myThreadUUID = "" />
         <cfset var myThreadContext = getPageContext().getFusionContext() />
         <cfset var myThreadName = myThreadContext.getCurrentUserThreadName() />

         <!---
             First, the thread will add itself to the tracker object
         --->         
         <cfset myThreadUUID = application.threadTracker.addThread(
                                     threadName = myThreadName,
                                     threadTask = myThreadContext.getUserThreadTask(myThreadName)     
                                 ) />

         <!---
             DO THREAD STUFF HERE .....
         ---> 


         <!---
             Finally, the finished thread will remove itself from
             the application tracker object
         --->         
         <cfset application.threadTracker.removeThread(
                                     threadUUID = myThreadUUID
                                 ) />
 </cfthread>

Now for the Usual Disclaimers....
As there is a bit too much code to post, I threw together a small example to demonstrate the concepts. It is rough and highly experimental. So use it at your own risk ;) Now I have only had a chance to test it on the Developer version. I am assuming it will work on the Standard edition too.

Anyway, for those interested in how it works, you can download the sample code from widget in the right menu. (Absolutely zero time went into window dressing. So if you have delicate eyes, you might want to leave the room now).