Converting a blocking call to non blocking

[Thomas Smets]

Ok,
The problem is rather simple, I want to convert a blocking call into a non-blocking call.
The solution I came up with is not working for an obvious reason : To "quit" the thread it has to be over & the other thread is stil running...
Could someone propose a better idea (or a working one )

Thomas SMETS,
SCJP, Brussels
--

  
package test.lang;
// get the latest Log4J class from jakarta.apache.org/Log4J/
import org.apache.log4j.Category;
import org.apache.log4j.BasicConfigurator;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import javax.swing.Timer;
public class NoBlockingCall  
{
  public static final int MAX_TIME_TO_WAIT = 1000;
  public static final int TIME_TO_SLEEP = 5000;
  public static final String MESSAGE 
    = "This is the message to access in the Blocking call";
  
  Category log = Category.getInstance (NoBlockingCall.class);
  
  String AStringToPopulate = null;
  
  public String call (int aTimeToWait )
  {
    try
    {
      new Timer (aTimeToWait, new ToRun()).start ();
      // Place here your blocking call that should be non-blocking
      AStringToPopulate = new Blocking().call();
    }catch (RuntimeException CEe)  
    {
      log.info ("Exception thrown " + CEe.getClass().getName());
      AStringToPopulate = null;
    } finally
    {
      //log.info ("In finally ");
    }
    return AStringToPopulate;
  }
/** 
  *
  */
  public static void main (String[] args)
  {
    BasicConfigurator.resetConfiguration ();
    BasicConfigurator.configure ();
    Category sLog = Category.getInstance (NoBlockingCall.class);
    sLog.info ("Started");
    NoBlockingCall nbc = new NoBlockingCall ();
    sLog.info ("Returned value : " + nbc.call (MAX_TIME_TO_WAIT));
  }
    
  public class ToRun
    implements ActionListener
  {
    ToRun ()
    {
      log.info ("ToRun created");
    }
    public void actionPerformed (ActionEvent anActionEvent)
      throws RuntimeException
    {
      log.info ("Start the Run-up time");
      throw (new RuntimeException ("This is my Exception from the ToRun"));
    }
  }
  
  public class Blocking    
  {
    public String call ()
    {
      log.info ("Blocking call");
      try
      {
        Thread.sleep (TIME_TO_SLEEP);
      }catch (Exception e)
      {
        log.warn ("Thread was Interrupted");      
      }
      return MESSAGE;
    }
  } 
}  // made with <a href="http://www.jcreator.com" target="_blank" rel="nofollow">www.jcreator.com</a>

[ April 24, 2002: Message edited by: Thomas SMETS ]

[Thomas Smets]

For the one interested here is the solution :

Firstly the blocking call :

  
package test.lang;
public class BlockingThread
  extends Thread
{
  public Blocking blk = null;
  public Object returnedValue = null;
  
  BlockingThread ()
  {
    blk = new Blocking ();
  }
  
  public void run ()
  {
    returnedValue = blk.call ();
  }
 
  public Object getValue()
  {
    return returnedValue;
  }  
}

Secondly a quick wrapper class :

  
package test.lang;
import org.apache.log4j.Category;
public class Blocking
{
  public static final String MESSAGE 
    = "This is the message to access in the Blocking call";
    
  public static final int MAX_TIME = 2500;
    
  Category log;
  
  public Blocking()
  {
    log = Category.getInstance (Blocking.class);
  }
  public String call (int aDelay)
  {
    log.info ("Blocking call");
    try
    {
      Thread.sleep (aDelay);
    }catch (Exception e)
    {
      log.warn ("Thread was Interrupted");
    
    }
    return MESSAGE;
  }
  
  public String call ()
  {
    return this.call (MAX_TIME);
  }  
}

Fianlly the call :

/**
  * Who ever wants to use this code could allegdly place the following 
  * line :
  *       Based upon an idea of Duffy JohnJ
  *       
  *   as posted on yahoogroups Advanced Java mailing list 
  *   SomeType callBlockingMethod(Blocking obj, long timeout) 
  *   {
  *     Thread t = new BlockingThread(obj);
  *     t.start();
  *     t.join(timeout);
  *     if (t.isAlive()) 
  *     {
  *        return null;
  *     } else 
  *     {
  *        return t.someValue();
  *     }
  *   }
  *
  */
package test.lang;
import org.apache.log4j.Category;
import org.apache.log4j.BasicConfigurator;

public class NonBlockingWrapper
{
  public Object callBlockingMethod(long timeout) 
  {
    BlockingThread t = new BlockingThread();
    t.start();
    Thread.currentThread ().yield ();
    try 
    {
      t.join(timeout);
    }
    catch (Exception ex) 
    {
      System.out.print ("Exception thrown");
    }
    
    if (t.isAlive()) 
    {
      return null;
    } else 
    {
      return t.getValue ();
    }
  }
/** 
  *
  */
  public static void main (String[] args)
  {
    BasicConfigurator.resetConfiguration ();
    BasicConfigurator.configure ();
    NonBlockingWrapper NBW = new NonBlockingWrapper();
    System.out.println ("Response is " + NBW.callBlockingMethod (3500));
  }
}

Thomas SMETS,
SCJP - Brussels