3
MyInterface intf = (MyInterface) Class.forName(className).newInstance();

I have a certain piece of code which will create new interfaces on demand using the above call and invoke a certain method. All of the implementation classes usually contain lots of final static variables and static initialization code which I would like to fire only once in its lifetime.

But since I am using the newInstance() call, I am under the impression that the old object gets GCed and the class is initialized again and hence all the static variables.

In order to avoid this, I would like to put this in a cache, so that these classes are not re-constructed again and hence would be initialized once during its lifetime. (Note: My interfaces are thread-safe).

Should I just put this in a Hashtable and just look it up or is there a better way to handle the cache?

Sean Patrick Floyd
  • 292,901
  • 67
  • 465
  • 588
user339108
  • 12,613
  • 33
  • 81
  • 112

6 Answers6

6

All of the implementation classes usually contain lots of final static variables and static initialization code which I would like to fire only once in its lifetime.

But since I am using the newInstance() call, I am under the impression that the old object gets GCed and the class is initialized again and hence all the static variables.

No, this is not true. Static fields and static blocks only run once -- when the class is loaded. So creating instances repeatedly will not rerun them. Also, they will not be garbage collected. So you don't have to worry about static fields being GCed and recreated repeatedly :-).

Additional note:

The above only applies if you only use the default classloader. If you use multiple classloaders and unload a classloader, then all the classes it loaded, along with their static fields will become eligible for GC. Also, static fields exist per classloader, not only per class, so if you load the same class using different classloaders, static initialization will indeed run multiple times. But this may not be a cocern for you...

Also see the discussion here:

Are static fields open for garbage collection?

Community
  • 1
  • 1
sleske
  • 81,358
  • 34
  • 189
  • 227
  • 1
    Or said the other way around: the same bytecode loaded by different classloaders results in different classes (with individual statics). – Paŭlo Ebermann Mar 17 '11 at 12:43
3

If I understand correctly you need to create new instances of your classes, and you want to be sure some initialization code is executed only once, and not every time that you call newInstance(). I think that if you put the initialization code in a static section, then you're fine: AFAIK the code in a static initializer block is executed once by the virtual machine when the class is loaded. See also this question.

Community
  • 1
  • 1
MarcoS
  • 13,386
  • 7
  • 42
  • 63
  • 1
    "code in a static initializer block is executed once by the virtual machine when the class is loaded". True; the catch is that a class may be loaded more than once if you use multiple class loaders. But if you do that, you should generally know what you are doing... – sleske Mar 17 '11 at 11:43
2

How about something like this:

private static Map<String, Object> cache = 
    new ConcurrentHashMap<String, Object>();

@SuppressWarnings("unchecked")
public static <T> T getImplementation(final String implementationClass){
    T result;
    synchronized(cache){
        result = (T) cache.get(implementationClass);
        if(result == null){
            try{
                result =
                    (T) Class.forName(implementationClass).newInstance();
            } catch(final Exception e){
                // error handling here
            }
            cache.put(implementationClass, result);
        }
    }
    return result;
}

This will guarantee that only one instance of each class is used (as long as you only use this method)

Example Usage:

FooService service = getImplementation("com.mycompany.FooServiceImpl");

Using Guava, this code could be improved with a Computing Map:

private static Map<String, Object> cache =
     new MapMaker().makeComputingMap(
         new Function<String, Object>(){

            @Override
            public Object apply(final String input){
                try{
                    return Class.forName(input).newInstance();
                } catch(final Exception e){
                    // error handling here
                }
            }
         });

@SuppressWarnings("unchecked")
public static <T> T getImplementation(final String implementationClass){
    return (T) cache.get(implementationClass);
}
Sean Patrick Floyd
  • 292,901
  • 67
  • 465
  • 588
2

How about this one.

static final Map<String, Object> instances = new HashMap<String, Object>();

public static Object getInstance(String name) {

    if (name == null) {
        return null;
    }
    Object obj = null;

    synchronized (ClassName.class) {
        try {
            obj = instances.get(name);
            if (obj == null) {
                obj = Class.forName(name).newInstance();
                instances.put(name, obj);
            }
        } catch (ClassNotFoundException e) {
        } catch (InstantiationException e) {
        } catch (IllegalAccessException e) {
        }
    }
    return obj;
}
Prince John Wesley
  • 62,492
  • 12
  • 87
  • 94
1

Use the singleton pattern: http://en.wikipedia.org/wiki/Singleton_pattern

endre
  • 1,363
  • 1
  • 11
  • 22
  • 1
    The classname is not known upfront to me, hence I wouldn't be able to have a class (say MyInterface1.getInstance()) or something, it just needs to be dynamically instantiated. Am I missing something here? – user339108 Mar 17 '11 at 11:30
0

This is called Singleton.
Using this pattern there'll be only one instance of your class.
There are some exceptions, however for most purposes you'll only have one instance.

Péter Török
  • 114,404
  • 31
  • 268
  • 329
Padmarag
  • 7,067
  • 1
  • 25
  • 29