Can a object created using static keyword be recreated? Singleton Pattern

Question

Hi All
To implement a Singleton I can use the following code
public Singleton {
private Singleton(){
private static final s_instance = new Singleton();
public Singleton getInstance(){
return s_instance;
Now if the Class Singleton gets unloaded during a program execution and again get loaded won't s_instance be recreated? If my question is correct this would lead to be leading to a new Singleton class instance with all the original variables.
Having answered the above question if I lazily initialize my Singleton using the following code won't the above problem still occur.
public Singleton {
private Singleton(){}
private final volatile Singleton s_instance = null;
public Singleton () {
if(s_instance != null) {
synchronized (s_instance) {
s_instance = new Singleton();
return s_instance;
Having answered all the above questions what is the best way to write a Singleton?

Answer 1

Would the class get unloaded even if the Singleton object has some valid/reachable references pointing to it?
On a different note, will all the objects/instances of a class get destroyed if the class gets unloaded.That's the other way round, really: instances cannot be garbage-collected as long as they are strongly reachable (at least one reference pointing to them), and classes cannot be unloaded as long as such an instance exists.
To support tschodt's point, see the JVM specifications: http://java.sun.com/docs/books/jvms/second_edition/html/Concepts.doc.html#32202
*2.17.8 Unloading of Classes and Interfaces*
A class or interface may be unloaded if and only if its class loader is unreachable. The bootstrap class loader is always reachable; as a result, system classes may never be unloaded.
Will the same case (Custom ClassLoader getting unloaded) occur if I write the singleton using the code wherein we lazily initialize the Singleton (and actually create a Singleton instance rather than it being a Class/static variable).You should check the meaning of this vocabulary ("object", "instance", "reference"): http://download.oracle.com/javase/tutorial/java/javaOO/summaryclasses.html
The difference between the lazy vs eager initializations is the time when an instance is created. Once it is created, it will not be garbage collected as long as it is reachable.
Now I'm wondering, whether being referenced by a static attribute of a class guarantees being reachabe. I'm afraid not (see the JLS definition of reachable: http://java.sun.com/docs/books/jls/third_edition/html/execution.html#44762). That is, again, unless the class has been loaded by the system class loader.