Java Threads vs. Native Global Variables

Question

A brief description of the problem:
I am trying to integrate a multi-threaded Java app with legacy Fortran code. The Fortran code in question makes extensive use of global variables in the form of Fortran's Common Block data structure.
If multiple threads were allowed access to a native routine, they would over write each others data which is stored in global variables.
If only one thread at a time can have access to the native routine for the duration of the native routine, the whole advantage of using threads is completely nullified.
These native routines cannot be rewritten (3rd party code) and must be used.
One solution I envisioned was to load a new copy of the native shared object code for each Java object that used the native code. However, it seems System.loadLibrary() can only be used in a static context.
Is there any known solution to this problem?

Answer 1

Here is an elaboration on the earlier suggestions. It's a high overhead solution, because you have to start a bunch of JVMs.
1. You have a java control program, which will start up a pool of "services", make requests to them, and gather the results.
2. Each service is a small java program with a native method:
o java communications front-end.
o native method declaration.
o native - in your case fortran - method implementation.
3. Each service is started using "exec". That puts it in a separate process.
4, Since each service is a java program, you can use java to do communications between the control program and the service.
o You could use RMI.
o You could - perhaps - use java Process communications, i.e., have the services write to stdout, and have the control program capture the output.
o You could use socket communications.