Singleton-Muster in Multi-threaded-Umgebung

Während mein interview, interviewer begann seine Frage mit singleton-Muster. Ich schrieb unten. Dann fragte er Sollten wir nicht überprüfen, für die Nichtigkeit innerhalb getInstance Methode?

Antwortete ich mit, Es ist NICHT notwendig, da Mitglied ist statischer Typ und initialisiert wird an der gleichen Zeit. Aber, scheint, wie er war nicht zufrieden mit meiner Antwort.Bin ich richtig oder nicht ?

class Single {

        private final static Single sing = new Single();       
        private Single() {
        }        
        public static Single getInstance() {
            return sing;
        }
    }

Nun, nächste Frage, die er Fragen schreiben singleton-Klasse für die multi-Threading-Umgebung. Dann schrieb ich überprüfen singleton-Klasse.

  class MultithreadedSingle {        
        private static MultithreadedSingle single;       
        private MultithreadedSingle() {
        }        
        public static MultithreadedSingle getInstance() {
            if(single==null){
                    synchronized(MultithreadedSingle.class){
                      if(single==null){
                            single= new MultithreadedSingle(); 
                              }      
                      }
                   }
             return single;
        }
    }

Dann, hatte er einen Einwand mit synchronized an und überprüfen Sie und sagte ist Es nutzlos. Warum sind Sie die überprüfung zweimal, und warum sind Sie mit synchronisiert ? Ich habe versucht, ihn zu überzeugen, mit mehreren Szenario. Aber, hat er nicht.

Später zu Hause versuchte ich folgenden code, wo ich bin, mit einfachen singleton-Klasse mit mehreren Threads.

public class Test {

    public static void main(String ar[]) {
        Test1 t = new Test1();
        Test1 t2 = new Test1();
        Test1 t3 = new Test1();
        Thread tt = new Thread(t);
        Thread tt2 = new Thread(t2);
        Thread tt3 = new Thread(t3);
        Thread tt4 = new Thread(t);
        Thread tt5 = new Thread(t);
        tt.start();
        tt2.start();
        tt3.start();
        tt4.start();
        tt5.start();

    }
}

final class Test1 implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " : " + Single.getInstance().hashCode());
        }
    }

}
     class Single {

        private final static Single sing = new Single();       
        private Single() {
        }        
        public static Single getInstance() {
            return sing;
        }
    }

Unten ist die Ausgabe :

Thread-0 : 1153093538
Thread-0 : 1153093538
Thread-0 : 1153093538
Thread-0 : 1153093538
Thread-0 : 1153093538
Thread-4 : 1153093538
Thread-1 : 1153093538
Thread-2 : 1153093538
Thread-3 : 1153093538
Thread-3 : 1153093538
Thread-3 : 1153093538
Thread-3 : 1153093538
Thread-3 : 1153093538
Thread-2 : 1153093538
Thread-2 : 1153093538
Thread-2 : 1153093538
Thread-2 : 1153093538
Thread-1 : 1153093538
Thread-1 : 1153093538
Thread-1 : 1153093538
Thread-1 : 1153093538
Thread-4 : 1153093538
Thread-4 : 1153093538
Thread-4 : 1153093538
Thread-4 : 1153093538

So, Frage ist, Ist es erforderlich, dass synchronize oder/und Doppel-check-Methode, die in den multi-Threading-Umgebung ? Wie es scheint, meinen ersten code selbst (ohne jede zusätzliche Zeile code) war die Antwort für beide Fragen. Jede Korrektur und wissen zu teilen, werden geschätzt.