Simple interest mode - lazy type

public class TestLazy {
    
	public static void main(String[] args) {
    
		Lazy l1 = Lazy.getInstance();
		Lazy l2 = Lazy.getInstance();
		
		System.out.println(l1 == l2);
		System.out.println(l1);
		System.out.println(l2);
	}
}

public class TestLazy {
    
	private static Lazy l1;
	private static Lazy l2;
	public static void main(String[] args) {
    
		Thread t1 = new Thread(){
    
			public void run(){
    
				l1 = Lazy.getInstance();
			}
		};
		
		Thread t2 = new Thread(){
    
			public void run(){
    
				l2 = Lazy.getInstance();
			}
		};
		
		t1.start();
		t2.start();
		
		// The function of adding this code is , Guarantee l1 and l2 After the assignment is completed, compare 
		try {
    
			t1.join();
			t2.join();
		} catch (InterruptedException e) {
    
			e.printStackTrace();
		}
		
		System.out.println(l1);
		System.out.println(l2);
		System.out.println(l1 == l2);
	}
}


class Lazy{
    
	//(2) Use a static variable to hold this unique instance 
	private static Lazy instance;// There's no way to new
	
	//(1) Constructor privatization 
	private Lazy(){
    
		
	}
	
	// Right 
/* //(3) When you get this object , And then to create  public synchronized static Lazy getInstance(){ if(instance == null){ instance = new Lazy(); } return instance; }*/
	
	
	//(3) When you get this object , And then to create 
	public static Lazy getInstance(){
    
		if(instance == null){
    // The function of this external condition is to improve efficiency   When this object has been created , So the thread behind , No matter how many , There is no need to wait for the lock 
			synchronized (Lazy.class) {
    //Lazy.class Get the... Of the current class Class object 
				if(instance == null){
    // The conditions are for safety 
					instance = new Lazy();
				}
			}
		}
		return instance;
	}
}

public class TestLazy {
    
	public static void main(String[] args) {
    
		LazyDemo.test();
		
		LazyDemo instance = LazyDemo.getInstance();
	}
}


class LazyDemo{
    
	//(1) Constructor privatization 
	private LazyDemo(){
    
		
	}
	
	// Inner class 
	private static class Inner{
    
		//（2） Use a static constant of the static inner class to save this unique object 
		public static final LazyDemo INSTANCE = new LazyDemo();
		
		static{
    
			System.out.println(" Static code block of inner class ");
		}
	}
	
	// When we call this method , Get external class object , Will lead to the loading and initialization of internal classes , Will lead to INSTANCE Object creation , So it also belongs to the lazy type 
	public static LazyDemo getInstance (){
    
		return Inner.INSTANCE;
	}
	
	// To test whether the inner class is loaded 
	public static void test(){
    
		System.out.println(" Static methods of external classes ");
	}
}