How can I kill a thread.

Question

I have read the many threads about killing a thread but they dont answer the question I need to know.
In class#1 I have the following snipet of code:
for (int i=0; i < docs.size(); i++)
    try {
        boolean blncompleted = false;
     Map object = null;
        OntologyCreatorThread  ontThread = new OntologyCreatorThread ();
     ontThread.start();
     ontThread.join(15000); // Allow thread to process for up to 15 seconds.
     // If thread is still running, kill the thread.  I dont care about
     // clean up since its only using memory and cpu, no DB is ever touched.
     if (ontThread.getState().toString().equals("RUNNABLE")){
         ontThread.interrupt();
            ontThread.stop();
            // set flag to false
         blncompleted = false;
        else {
            // set flag to false and do a ton of other processing.
         blncompleted = false;
         object = ontThread.getObject();
    catch (Exception Ex){
        Ex.printStackTrace();
In my thread I have the following:
public class OntologyCreatorThread extends Thread {
    Map object = null;
    public OntologyCreatorThread(){
    public void run() {
       try {
         // The line below takes forever to run sometimes.
         object = functionCallToApi(stringOfText);
    public Map getObject() {
     return objects;
If the thread takes to long to run I just want to kill it.
I have tried interupt and stop and both dont work.  Inside the run method of the thread I call an external API
which I pass a string of text.  I can not get into that code because its from a Off the shelf product that we dont
have the code to.  If the call in the run method takes to long I want to just kill this thread in the main class(#1). 
No matter what I do I cant get the damn thing to stop.
The line below takes forever to run.
         object = functionCallToApi(stringOfText);
Putting it in a while loop wont solve this problem because the processing is still taking place in the call to the api.
Thanks in advanceMessage was edited by:
Storm897

Answer 1

Couple of things to consider:
1. Note that Thread.interrupted() and t.isInterrupted() are very different methods. The former clears the interrupted status so that a subsequent call will return false. The latter does not affect the interrupt status on the thread.
2. If your "atomic step one" catches an Exception, then you might be swallowing an InterruptedException. Basically the rule when a Thread is interrupted is that if it is in a blocking call, an InterruptedException is thrown. Otherwise, isInterrupted is set to true. So if you have blocking (I/O) calls in "atomic step one" and you're catching Exception, then it might be that the InterruptedException goes completely unnoticed.
3. If "atomic step one" takes a long time and you really want to abort the thread instantly, then you need some kind of method for doing so--you need to program in safe "stopping points". For example:
public class Helper implements Runnable {
   private boolean _continue = true;
   public void cancel() {
      _continue = false;
   public void run() {
      _continue = true;
      try {
         // Do something until in safe/stable state
         if(!_continue) return;
         // Do something until in safe/stable state
         if(!_continue) return;
         while(_continue) {
             // process single record in large data set
             // Safe to stop at the end of each loop
         if(!_continue) return;
         // Do something else . . . etc.
      } catch(InterruptedException ie) {
         _continue = false; // Unnecessary, but here for illustration
}Casual programmers often don't care whether the thread stops safely or not, but it really is important especially if you are in the middle of some kind of transaction. That's why destroy(), cancel() et al are deprecated.