Forwards compatible program possible?

Thread view:

jonasforssell@yahoo.se - 25 Jul 2006 17:10 GMT

Hello Experts,

The 1.4 API has a few very useful functions like
Runnable.getNumberOfProcessors()

Is it possible to write a program which uses these if possible but does
not demand a 1.4 JRE and disables the feature if run on an 1.2 JRE?

If so, how would an example look like?

Thanks
/Jonas Forssell, Gothenburg, Sweden

Reply to this Message

Patricia Shanahan - 25 Jul 2006 18:46 GMT

> Hello Experts,
>
[quoted text clipped - 8 lines]
> Thanks
> /Jonas Forssell, Gothenburg, Sweden

How about reflection?

try {
Method m = Runtime.class.getDeclaredMethod(
"availableProcessors",new Class[0]);
Object o = m.invoke(Runtime.getRuntime(),new Object[0]);
return ((Integer)o).intValue();
} catch (NoSuchMethodException e) {
return 1;
}

You will need more exception handling. The NoSuchMethodException block
should return whatever number of processors you want to assume in the
1.2 JRE.

Patricia

Reply to this Message

jonasforssell@yahoo.se - 25 Jul 2006 21:28 GMT

Patricia Shanahan skrev:

> > Hello Experts,
> >
[quoted text clipped - 25 lines]
>
> Patricia

Excellent proposal.
Thanks for your help!
/jonas

Reply to this Message

Jean-Francois Briere - 25 Jul 2006 22:01 GMT

To avoid reflection you could write your 1.4+ specific code in an
helper/utility class.
Each method would have to do try { } catch (NoSuchMethodError e) { } in
its body.
Then compile this class with a 1.4+ compiler with flags: -source 1.2
-target 1.2

public class Utils {
public static int getNbrOfProcs() {
try {
// 1.4+ code
return Runtime.getRuntime().availableProcessors();
}
catch (NoSuchMethodError e) {
// Maybe print something
return 1;
}
}
}

Regards

Reply to this Message

Thomas Hawtin - 26 Jul 2006 15:01 GMT

> To avoid reflection you could write your 1.4+ specific code in an
> helper/utility class.
[quoted text clipped - 15 lines]
> }
> }

Dangerous thing to do. The point the exception is thrown from is not
always obvious, for frequently executed code it can be slow and it does
not clearly distinguish between 1.2 and 1.4 code. There's a piece on it
in Java Puzzlers.

My preferred approach allows the 1.2 code to be compiled against the 1.2
rt.jar. Make a class of 1.4 specific stuff that implements an 1.2
compatible interface. Compile the 1.4 class with -target 1.4 and use the
static initialiser to check that it really is running on 1.4+. The 1.2
code can be compiled against the 1.2 rt.jar and use Class.forName to
load the 1.4 specific stuff (once).

Tom Hawtin