设计模式之单例模式

Java 设计模式之单例模式

单例模式的三种实现方式

1. 饿汉式

饿汉式顾铭思议是在类加载时便生成对象，由于在类加载的时候就生成了对象，饿汉式是线程安全的，但是会造成空间的浪费。

package com.lin.lon;

public class SingletonForHungry {

    public static SingletonForHungry singleton= new SingletonForHungry();
    private SingletonForHungry(){
        
    }
    public static SingletonForHungry getInstance(){
        return singleton;
    }
}

2.懒汉式

懒汉式相对于饿汉式而言，只有在方法被调用的时才会创建对象，由于懒汉式是动态的调用，因此会存在线程安全问题。

• 第一种实现方式，该实现方式会造成线程安全问题

package com.lin.lon;

public class SingletonForLangOne {
    private static SingletonForLangOne singletonForLang;
    private SingletonForLangOne(){

    }
    public static SingletonForLangOne getInstance(){
        if (singletonForLang == null){
            return  new SingletonForLangOne();
        }else {
            return singletonForLang;
        }
    }

}

• 第二种实现方式，该方式能够避免线程安全问题，但会影响性能，一般有两种写法，推荐第二种写法，第一种写法消耗的性能过大

package com.lin.lon;

public class SingletonForLangTwo {
    private static SingletonForLangTwo singletonForLang;

    private  SingletonForLangTwo(){

    }
    public static synchronized SingletonForLangTwo getInstance(){
        if (singletonForLang == null){
            return  new SingletonForLangTwo();
        }else {
            return singletonForLang;
        }
    }

}

package com.gupaoedu.singleton;

public class Singleton3 {

	private Singleton3() {}

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

• 第三种实现方式，该方式能够很好的兼顾懒汉式的动态与线程安全问题造成的性能损失

package com.lin.lon;

public class SingletonForLangThree {

    private static class InnerForSingle{
        private static final SingletonForLangThree singletonForLang = new SingletonForLangThree();
    }

    private  SingletonForLangThree(){

    }
    public static synchronized SingletonForLangThree getInstance(){

            return InnerForSingle.singletonForLang;

    }
}

3.注册式

Spring中即采用此种方式，注册时是在启动时将类名和类注册到Map中，当需要使用时传递给方法所需要使用的类名即可获得该对象

package com.lin.lon;

import java.util.HashMap;
import java.util.Map;

public class SingletonForRegister {
    private static Map<String,SingletonForRegister> objectMap = new HashMap<>();
    private SingletonForRegister(){

    }
    //类加载时将对象注入Map
    static {
        SingletonForRegister singleton = new SingletonForRegister();
        objectMap.put("com.lin.lon.SingletonForRegister",singleton);
    }

 //该处可能会存在线程安全问题，博主目前还没有更好的实现方式，不影响性能
    public static SingletonForRegister getInstance(String  className){
        if (className == null){
            className = SingletonForRegister.class.getName();
        }
        if (objectMap.get(className) ==null){
            try {
                objectMap.put(className, (SingletonForRegister) Class.forName(className).newInstance());
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
        return  objectMap.get(className);
    }
}