The MethodThread Package for Java

This package provides two classes to implement the above functionality. The first class, MethodThread, is a subclass of Thread that accepts a different kind of target object than those implementing the Runnable interface. One such target object is the other class provided in this package, ReflectiveInvocation. The ReflectiveInvocation class reflectively invokes a method or constructor that may be specified using an instance of Method or Constructor or, more importantly, by name. The extension to the Reflection functionality is that the search for a named method or constructor is based on matching the arguments but taking into account superclasses and interfaces. Currently, Java Reflection is only capable of searching for a named method or constructor based on an exact match of argument types.

1. The single entry point style of programming is inelegant and restrictive. It forces programmers to implement their own protocol for invoking a method and retrieving results (not entirely unlike the stubs and skeletons generated by the rmic tool), which must be updated when the interface to a class is changed. The more general approach of allowing any method to be invoked removes some of this effort.
2. The current thread facilities fail when considering the case where multiple threads are executed on the same target object, which is common in parallel programming. There are actually two facets to this problem:
   • The run() does not allow parameters to be given to a thread. Typically, when creating multiple threads on a single target object, each thread is responsible for a part of the computation and thus needs to be distinguished from the other threads, which is easily accomplished with parameters. While it is possible to accomplish this using a form of double dispatch (create a set of objects representing the parameters and start threads on theses objects, which use the original target to compute their results), this may require additional programming effort (particularly if there are multiple parameters).
   • It would be nice to allow a thread to return a result. This is true in general, but having multiple threads on a single target object makes this difficult. Implementing this requires a separate buffer where results can be written by the thread and read when the thread has finished.

The only other changes to normal threads are the added methods joinWithValue() and getException(). The joinWithValue() method joins with the executing thread and returns the result of the invoked method (there are also versions of this method that will attempt to join with the thread for a given time interval, just like the join() method). The getException() method returns the first exception thrown during the execution of the invoked method.

It is important to note that this class is a subclass of the existing Thread class. This means that all the normal thread operations, such as join() should still work (although not all have been fully tested). Also, it means that the existing ThreadGroup class can also be used as a container. The only difference may be that the thread object will require a cast to invoke methods specific to the MethodThread class.

This package also provides the ReflectiveInvocation class, which implements RunnableWithResult. This class reflectively invokes a method or constructor based on one of the following sets of parameters:

1. a target object, a Method object representing the desired method, and the arguments to the method.
2. a Constructor object representing the desired constructor and the arguments to the constructor.
3. a target object or class, the name of the desired method, and the arguments to the method.
4. the class or name of the desired constructor and the arguments to the constructor.

To facilitate the creation of threads executing arbitrary methods or constructors, the MethodThread class provides an extensive list of factory methods. These factory methods, used to create instances of MethodThread, accept thread-specific parameters as well as the parameters needed to create an instance of ReflectiveInvocation, which is used as the internal target object of the new thread.

    public class Test
    {
       public Object method(Integer a)
       {
            ...
       } /* method */
    } /* Test */

The following code fragment demonstrates how to execute a thread on the method method() on an instance of the class Test. For simplicity, this code only catches general exceptions rather than catching each individual exception that may be thrown.

    import java.lang.* ;

    public class Example
    {
       public static main(String[] argv)
       {
          Test obj = new Test() ;
          Object result ;
          Object args = new Object[1] ;
          args[0] = new Integer(5) ;

          try {

             // Create a thread that executes obj.method(args)
             MethodThread t =
                     MethodThread.createMethodThread(obj, "method", args) ;

             // Start the thread executing.
             t.start();

             // Join with the thread and retrieve the return value.
             result = t.joinWithValue() ;

          } catch (Exception e) {
               ...
          } /* try */
       } /* main */
    } /* Example */

In this example, the string "method" is matched against all public methods that can be invoked on the target object obj using the argument types, in this case a parameter that is an instance of Integer.

We can change the above to use Method objects as follows. If methodObj is an instance of the Method class and represents the method(Integer) method in class Test, then we can instantiate the thread as follows:

   MethodThread t = MethodThread.createMethodThread(obj, methodObj, args) ;

In the above fragment, it is verified that the number of arguments expected by the methodObj method are supplied by the args array. For now, there is no check to determine if the supplied arguments are compatible with the expected ones. This is done when the method is invoked by the thread, at which point it is not possible to throw exceptions in the application code. However, these exceptions can be retrieved using the getException() method.

One of the improvements in the class allows the user to optimize the case where several threads are created to execute the same method. Originally, this could only be done with the following code:

     MethodThread[] t = new MethodThread[numberOfThreads] ;
     for(int i = 0;i < numberOfThreads;++i) {
          args = ... ;
          t[i] = new MethodThread(target, "method", args) ;
     } /* for */

     args = ... ;
     MethodThread[] t = new MethodThread[numberOfThreads] ;
     Method m = ReflectiveInvocation.findMethod(target, "method", args) ;
     for(int i = 0;i < numberOfThreads;++i) {
          t[i] = new MethodThread(target, m, args) ;
     } /* for */

It is important to note that the arguments to the thread are not cloned but are references to the original objects. This means that any changes made via side effects are visible to the caller, just like normal method parameters. This was true of earlier versions as well. To ensure the consistency of the data, you will need to join with the thread before accessing the affected parameters.