登记式单例模式是对一组单例模式进行的维护, 保证 map 中的对象是同一份 Spring 中使用的就是类似的模式:

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class RegisterSingleton {
    /** * 登记式单例模式, 保证map中的对象是同一份 */
    private static Map<String, Object> map;

    static {
        map = new ConcurrentHashMap<>();
        map.put(RegisterSingleton.class.getName(), new RegisterSingleton());
    }

    private RegisterSingleton() {
        System.out.println("this Constructor is called");
    }

    public static Object getInstance(String name) {
        if (name == null) {
            name = RegisterSingleton.class.getName();
        }
        if (map.get(name) == null) {
            try {
                map.put(name, Class.forName(name).newInstance());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return map.get(name);
    }
}

反序列化机制破解单例模式（枚举除外）：

public class BreakSingleton{

  public static void main(String[] args) throws Exception{

     //先根据单例模式创建对象(单例模式所以s1,s2是一样的)
     Singleton s1=Singleton.getInstance();
     Singleton s2=Singleton.getInstance();

//将s1写入本地某个路径
     FileOutputStream fos=new FileOutputStream("本地某个路径下文件");
     ObjectOutputStream oos=new ObjectOutputStream(fos);
     oos.writeObject(s1);
     oos.close();
     fos.close();

//从本地某个路径读取写入的对象
     ObjectInputStream ois=new ObjectInputStream(new FileInputStream("和上面的本地参数路径相同"));
    Singleton s3=(Singleton) ois.readObject();
     System.out.println(s1);
     System.out.println(s2);
     System.out.println(s3);//s3是一个新对象
}
 
}

如何避免实现序列化单例模式的漏洞：

class Singleton implements Serializable{

  private static final Singleton singleton = new Singleton(); 

  private Singleton() {
  }
  public static Singleton getInstance(){
         return singleton;
  }
//反序列化定义该方法，则不需要创建新对象
  private Object readResolve() throws ObjectStreamException{
    return singleton;
  }
}

反射机制破解单例模式（枚举除外）：

public class BreakSingleton{
    public static void main(String[] args) throw Exception{
        Class clazz = Class.forName("Singleton");
        Constructor c = clazz.getDeclaredConstructor(null);

        c.setAccessible(true);

        Singleton s1 = c.newInstance();
        Singleton s2 = c.newInstance();
        //通过反射，得到的两个不同对象
        System.out.println(s1);
        System.out.println(s2);
    }
}

如何避免以上的漏洞：

class Singleton{
    private static final Singleton singleton = new Singleton(); 
        private Singleton() {
        //在构造器中加个逻辑判断,多次调用抛出异常
        if(instance!= null){
            throw new RuntimeException()
        }
    }
    public static Singleton getInstance(){
        return singleton;
    }
}

单例模式中的饿汉模式

class Singleton{
public static String a = "11";
private static byte[] bytes = new byte[100*88];

// 这句就是饿汉模式的核心
private static final Singleton singleton = new Singleton(); 

private Singleton() {}
public static Singleton getInstance(){
         return singleton;
     }
}

懒汉式与饿汉式的根本区别在与是否在类内方法外创建自己的对象。

并且声明对象都需要私有化，构造方法都要私有化，这样外部才不能通过 new 对象的方式来访问。

饿汉式的话是声明并创建对象(因为他饿)，懒汉式的话只是声明对象，在调用该类的 getinstance() 方法时才会进行 new 对象。