Preventing Multiple Init problem

Question

Hello,
This is something I should already now, but I have myself stumped.
I have a servlet that has some static instance variables to some singleton objects, and some Strings and some other objects, which get initialized in the init() method when my servlet gets loaded. When another instance of my servlet is created, I don't want it to re-initialize those objects. For most of them it would be okay, but there are a few that would cause problems. So, I was wondering what would be a good way to ensure that a servlet only initialized certain instance variables once, and any future servlet instances would skip that initialization and use the values that were already initialized by the first instance? I wrote the following test program:
public class TestBool
     static boolean testBool;
     static String testString;
     public static void main(String[] args)
          Thread main = Thread.currentThread();
          System.out.println( (testString == null ? "true":"false") );
          testString = "no";
          try
               main.sleep(30000);
          catch(Exception e)
               e.printStackTrace();
}I then ran it once, then ran another instance of it, but the second instance seems to reset that testString to null when it runs, so they both output "true"... I am also assuming that both instances I ran were running in the same JVM. So, I am assuming the same thing may happen to my servlets. Any advice and/or expertise would be greatly appreciated! Thanks!

Answer 1

I am using a multi-threaded servlet, but from my
understanding, it is still possible to end up with
more than one instance of a multi-threaded servlet if
there is enough load on the server that it needs to
create another instance to serve all the requests.
(Let me know if that is incorrect).According to the servlet spec, the container must use only one instance of a multi-threaded servlet class. Load does not impact this because the server can create more threads - another instance would not help. However, it's probably safer to code defensively because it's possible that your servlet could be changed later to a single thread servlet and who knows if all servlet engines follow the spec.
I guess
my real question is, when it goes to create another
instance... will the static declarations reset the
references to null, or should I be able to check if
fooString is null and skip initialization if it is not
null?The static declarations are initialized when the class is loaded, so object creation has no impact. To be super-safe, you should synchronize the code that initializes the variables. In my previous post I synchronized on the object but it should have been on the class.
public void init(ServletConfig config) throws ServletException {
      if (fooString == null) {
            synchronized (FooServlet.class)
                if (fooString == null) {
                    fooSingleton= SingletonClass.getInstance();
                    fooString = config.getInitParameter("fooValue");
}All of this is probably more safety than you need! There should be only one instance of the servlet, and this code handles multiple instances being created concurrently. As long as the app is not distributable across multiple JVMs, then you should be ok.