难写的单例模式

快来打我* 2022-08-18 03:05 95阅读 0赞

**概念：**  
　　java中单例模式是一种常见的设计模式，[单例模式][Link 1]分三种：懒汉式单例、饿汉式单例、登记式单例三种。  
　　单例模式有一下特点：  
　　1、单例类只能有一个实例。  
　　2、单例类必须自己创建自己的唯一实例。

3、单例类必须给所有其他对象提供这一实例。

**优点：**

单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，[线程池][Link 2]、缓存、日志对象、对话框、

打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能

有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以

避免一个通信端口同时被两个请求同时调用。总之，选择[单例模式][Link 1]就是为了避免不一致状态，避免政出多头。

**Not That：**

然而单例模式真的有那么好吗，我想说的是，我们应该尽量少使用单例模式，

因为一旦实现就很难改变或重载，而且会造成编写测试用例困难、代码结构糟糕等问题。

另外，我会说明单例模式是不安全的。

**懒汉式：**

public class Singleton {
    	    private static Singleton instance;  
    	    private Singleton (){}  
    	  
    	    public static Singleton getInstance() {  
    	    if (instance == null) {  
    	        instance = new Singleton();  
    	    }  
    	    return instance;  
    	    }  
    }

为什么称它为懒汉啦，因为他非常的懒，只要在需要这个单例的时候，它才给你去加载；

但是这个方法的defect也非常明显，那就是它不是线程安全的；

public static synchronized Singleton getInstance() {  
    	    if (instance == null) {  
    	        instance = new Singleton();  
    	    }  
    	    return instance;  
    	    }

### 双重检查加锁： ###

public class Singleton {
    	    private static volatile Singleton singleton; 
    	    private Singleton (){}  
    	  
    	    public static  Singleton getInstance() {  
    	    if (singleton == null) {  
    	    	//同步代码块
    	       synchronized(Singleton.class){
    	    	   if(singleton != null){ //双重校验
    	    		   singleton=new Singleton();
    	    	   }
    	       }
    	    }  
    	    return singleton;  
    	    }  
    }

所谓“双重检查加锁”机制，指的是：并不是每次进入getInstance方法都需要同步，

而是先不同步，进入方法后，先检查实例是否存在，如果不存在才进行下面的同步

块，这是第一重检查，进入同步块过后，再次检查实例是否存在，如果不存在，就

在同步的情况下创建一个实例，这是第二重检查。这样一来，就只需要同步一次了，从

而减少了多次在同步情况下进行判断所浪费的时间。

**静态内部类：**

public class Singleton {    
        private static class LazyHolder {    
           private static final Singleton INSTANCE = new Singleton();    
        }    
        private Singleton (){}    
        public static final Singleton getInstance() {    
           return LazyHolder.INSTANCE;    
        }    
        
        public static void main(String[] args) {
    		Singleton singleton=Singleton.getInstance();
    		System.out.println(singleton);
    	}
    }

当getInstance方法第一次被调用的时候，它第一次读取SingletonHolder.instance，导致SingletonHolder类得到初始化；而这个类在装载并被初始化的时候，会初始化它的静态域，从而创建Singleton的实例，由于是静态的域，因此只会在虚拟机装载类的时候初始化一次，并由虚拟机来保证它的线程安全性。

这个模式的优势在于，getInstance方法并没有被同步，并且只是执行一个域的访问，因此延迟初始化并没有增加任何访问成本。

## 要小心序列化: ##

如果单例实现了序列化，它就要面临另一个威胁。因此需要将所有字段声明为transient

（这样它就不会被序列化）并提供一个自定义的readResolve()方法返回唯一实例INSTANCE的引用。

**饿汉式单例:**

什么叫饿汉式，顾名思义就是非常的饿，已经迫不及待得想得到这个单例了。

public class Singleton1 {  
        private Singleton1() {}  
        private static final Singleton1 single = new Singleton1();  
        //静态工厂方法   
        public static Singleton1 getInstance() {  
            return single;  
        }  
    }

饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以不用担心线程问题，但是缺点很明显

了，你可以重新new一个类出来，也可以通过反射映射出一个类来;

public class Singleton {  
        private static final Singleton single = new Singleton();  
        //静态工厂方法   
        public static Singleton getInstance() {  
            return single;  
        }  
        public static void main(String[] args) throws Exception {
        	Constructor[] constructors = Singleton.class.getDeclaredConstructors(); //得到构造函数
        	Constructor constructor = constructors[0];
        	constructor.setAccessible(true); //权限控制
        	Singleton singleton1 = (Singleton) constructor.newInstance(new Object[0]); //创建一个新的单例
        	Singleton singleton=Singleton.getInstance();
        	Singleton singleton2=new Singleton();
        	System.out.println(singleton1==singleton2);
    	}
    }

所以我们需要对构造方法进行修饰一下，避免多次调用

这样看起来安全一些了，但其实要创建新的实例还是一样容易。我们只需修改INSTANCE\_CREATED字段，在执行构造方法就可以了；

public class Singleton {  
        private Singleton() {
        	 if (INSTANCE_CREATED) {
                 throw new IllegalStateException("You must only create one instance of this class");
             } else {
                 INSTANCE_CREATED = true;
             }
        }  
        private static boolean INSTANCE_CREATED;
        private static final Singleton single = new Singleton();  
        //静态工厂方法   
        public static Singleton getInstance() {  
            return single;  
        }  
        public static void main(String[] args) throws Exception {
        	Field f = Singleton.class.getDeclaredField("INSTANCE_CREATED");
        	f.setAccessible(true);
        	f.set(null, false);
        	Constructor[] constructors = Singleton.class.getDeclaredConstructors();
        	Constructor constructor = constructors[0];
        	constructor.setAccessible(true);
        	Singleton spuriousFoo = (Singleton) constructor.newInstance(new Object[0]);
        	Singleton singleton=Singleton.getInstance();
        	System.out.println(singleton);
    	}
    }

**登记式单例(可忽略)**

//类似Spring里面的方法，将类名注册，下次从里面直接获取。  
    public class Singleton {  
      private static Map<String,Singleton> map = new HashMap<String,Singleton>();  
      static{  
          Singleton single = new Singleton();  
          map.put(single.getClass().getName(), single);  
      }  
      //保护的默认构造子  
      protected Singleton(){}  
      //静态工厂方法,返还此类惟一的实例  
      public static Singleton getInstance(String name) {  
          if(name == null) {  
              name = Singleton.class.getName();  
              System.out.println("name == null"+"--->name="+name);  
          }  
          if(map.get(name) == null) {  
              try {  
                  map.put(name, (Singleton) Class.forName(name).newInstance());  
              } catch (InstantiationException e) {  
                  e.printStackTrace();  
              } catch (IllegalAccessException e) {  
                  e.printStackTrace();  
              } catch (ClassNotFoundException e) {  
                  e.printStackTrace();  
              }  
          }  
          return map.get(name);  
      }     
      public static void main(String[] args) {  
          Singleton single = Singleton.getInstance(null); 
          Singleton single1 = Singleton.getInstance(null);  
          System.out.println(single);  
          System.out.println(single1);
      }  
    }

登记式单例实际上维护了一组单例类的实例，将这些实例存放在一个Map（登记薄）中，对于已经登记过的实例，则从Map直接返回，对于没有登记的，则先登记，然后返回。

先它用的比较少，另外其实内部实现还是用的饿汉式单例，因为其中的static方法块，它的单例在类被装载的时候就被实例化了,最重要的一点就是代码太多了，不简洁；

**单例和枚举:**

public enum SingletonEnum {
    	INSTANCE;
        public static SingletonEnum getInstance() { return INSTANCE; }
        public void singletonOperation(){        //功能处理   
        	};
    }

根据Java语言规范8.9，“Enum的final克隆方法保证枚举永远无法被克隆，其特殊的序列化机制保证

无法反序列化得到拷贝的对象。同时，还禁止利用反射对枚举进行实例化。保证了这四个方面，在枚举常量之

外，就不会有其他同类的枚举实例存在。”很简单地就防范了序列化、克隆和反射的攻击。

**凡事无绝对:**

public enum SingletonEnum {
    	INSTANCE;
        public static SingletonEnum getInstance() { return INSTANCE; }
        public void singletonOperation(){        //功能处理   
        	};
        	public static void main(String[] args) throws Exception {
        		Constructor con = SingletonEnum.class.getDeclaredConstructors()[0];
        		 Method[] methods = con.getClass().getDeclaredMethods();
        		 for (Method method : methods) {
        		     if (method.getName().equals("acquireConstructorAccessor")) {
        		         method.setAccessible(true);
        		         method.invoke(con, new Object[0]);
        		     }
        		  }
        		  Field[] fields = con.getClass().getDeclaredFields();
        		  Object ca = null;
        		  for (Field field : fields) {
        		      if (field.getName().equals("constructorAccessor")) {
        		          field.setAccessible(true);
        		          ca = field.get(con);
        		      }
        		  }
        		  Method method = ca.getClass().getMethod("newInstance", new Class[]{Object[].class});
        		  method.setAccessible(true);
        		  SingletonEnum spuriousEnum = (SingletonEnum) method.invoke(ca, new Object[]{new Object[]{"SPURIOUS_INSTANCE", 1}});
        		  printInfo(SingletonEnum.INSTANCE); //枚举一
        		  printInfo(spuriousEnum); //枚举二
        		}
        		private static void printInfo(SingletonEnum e) {
        		    System.out.println(e.getClass() + ":" + e.name() + ":" + e.ordinal());
        		}
    }

枚举的缺点是它无法从另一个基类继承，因为它已经继承自java.lang.Enum枚举一个优点是，如

果你之后希望有“二例（dualton）”或“三例（tringleton）”，只需要增加新的枚举实例即可。例

如，有了一个单例的缓存之后，你也许还想给缓存引入多个层次。

[Link 1]: http://baike.baidu.com/subview/1859857/1859857.htm
[Link 2]: http://baike.baidu.com/subview/262150/262150.htm