singleton单例模式

单例模式

1. 饿汉式单例模式

   public class SingletonDemo1 {
   
       // 饿汉式加载类时直接创建对象，不能实现延时加载
       private static SingletonDemo1 singleton = new SingletonDemo1();
       
       // 私有化构造方法
       private SingletonDemo1(){}
   
       // 对外提供方法获取对象
       public static SingletonDemo1 getInstance(){
           return singleton;
       }
   }
   

2. 懒汉式单例模式

   public class SingletonDemo2 {
   
       // 懒汉式加载类时先不加载对象，实现了延时加载
       private static SingletonDemo2 singleton;
   	
   	// 私有化构造方法
       private SingletonDemo2() {}
   
       // 对外提供方法获取对象，懒汉式为了防止线程高并发产生多个对象需要加锁
       // 同步方法，调用效率低
       public static synchronized SingletonDemo2 getInstance() {
           if (singleton == null) {
               singleton = new SingletonDemo2();
           }
           return singleton;
       }
   }
   

3. 双重检验单例模式

   public class SingletonDemo3 {
   
       // 双重检验锁加载类时先不加载对象，实现了延时加载
       private static SingletonDemo3 singleton;
   	
       // 私有化构造方法
       private SingletonDemo3() {}
   
       //对外提供方法获取对象
       public static SingletonDemo3 getInstance() {
           // 由于jvm底层机制，可能会返回没有构建完成的对象
           if (singleton == null) {
               synchronized(SingletonDemo3.class){
                   if (singleton == null){
                       singleton = new SingletonDemo3();
                   }
               }
           }
           return singleton;
       }
   }
   

4. 静态内部类单例模式(完美)

   public class SingletonDemo4  implements Serializable,Cloneable {
   
       // 静态内部类可以实现懒加载，线程安全，调用效率高
       private static class Singleton{
           private static SingletonDemo4 singleton = new SingletonDemo4();
       }
   
       @Override
       protected Object clone() {
           return Singleton.singleton;
       }
   
       // 私有化构造方法
       private SingletonDemo4() {
           if (null != Singleton.singleton) {
               throw new RuntimeException("试图产生多个对象");
           }
       }
       public static SingletonDemo4 getInstance(){
           return Singleton.singleton;
       }
   
       /**
       * 防止反序列化产生多个对象
       * @return
       */
       private Object readResolve(){
           return Singleton.singleton;
       }
   }
   

5. 枚举单例模式

   // 不能实现懒加载，但是线程安全，天然防止序列化和反射
   

public enum SingletonDemo5 {

    INSTANCE;
    
    // 添加一些自己的方法
public void doSomething() {

    }
}
```

防止反序列化产生多个对象添加readResolve()方法

private Object readResolve(){
    return Singleton.singleton;
}

防止反射产生多个对象

private SingletonDemo4() {
    if (null != Singleton.singleton) {
        throw new RuntimeException("试图产生多个对象");
    }
}

防止克隆产生多个对象，重写clone()方法

@Override
protected Object clone() {
    return Singleton.singleton;
}