单例模式instance

墨蓝 2022-03-20 05:46 72阅读 0赞

单例模式是设计模式中最简单的模式了，它的目的是为了保证一个流程中只有一个对象存在，相当于一个全局变量。

**1 单例模式的实现**  
创建一个类，调用者不能通过默认构造方法的方式创建实例，而是提供一个接口用来返回唯一的实例。

**2 同步单例模式的实现**  
1中是最简单的单例模式，但是在多线程状态下就出现问题了，如果线程A调用getInstance()方法时，开始先判断instance是否为空，如果为空则需要创建实例，但是此时A线程阻塞，B线程也调用了getInstance()方法，也发现Instance为空，所以需要创建实例，此时A线程继续执行，则又创建了一个实例，A和B线程各创建了一个实例对象，违背了单例模式的初衷，所以需要实现单例模式的线程同步。

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

**3 提高单例模式的性能**  
2中的单例模式保证了线程的同步问题，但是也存在着问题，那就是性能问题，采用synchronized关键字来回对方法加锁有很大的性能开销，那么能否只对某个对象加锁呢，答案是可以的。去掉方法同步的关键字synchronized，对SingleInstance.class进行加锁操作，代码可如下:

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

接下来的问题是当多个线程同时获取实例时，依然要对某个对象进行同步操作，有没有更好的办法呢，答案是有的，那就是在同步之前先判断Instance是否为空，如果已经是非空了，也就没必要同步了，那么可以改成如下的代码，如下所示：

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

看似没有任何问题了，其实不然，主要问题在于instance = new SingleInstance()这行代码并不是原子性的，也就是说，这行代码需要处理器分为多步才能完成，其中主要包含两个操作，分配内存空间，引用变量指向内存，由于编译器可能会产生指令重排序的优化操作，所以两个步骤不能确定实际的先后顺序，假如线程A已经指向了内存，但是并没有分配空间，线程A阻塞，那么当线程B执行时，会发现Instance已经非空了，那么这时返回的Instance变量实际上还没有分配内存，显然是错误的。

**4 单例模式中的volatile**  
volatile是Java提供的关键字，它具有可见性和有序性，被volatile修饰的写变量不能和之前的读写代码调整，读变量不能和之后的读写代码调整，所以，只要把instance加上volatile关键字就可以避免3中的问题了。代码如下所示：

public class SingleInstance{
        private static volatile SingleInstance instance = null;
        private SingleInstance(){}
        public static SingleInstance getInstance(){
            if(instance == null){
                synchronized(SingleInstance.class){
                    if(instance == null){
                        instance = new SingleInstance();
                    }        
                }
            }
            return instance;    
        }
    }

**5.enum实现方式**  
传统的两私有一公开（私有构造方法、私有静态实例(懒实例化/直接实例化)、公开的静态获取方法）涉及线程安全问题（即使有多重检查锁也可以通过反射破坏单例），

目前最为安全的实现单例的方法是通过内部静态enum的方法来实现，因为JVM会保证enum不能被反射并且构造器方法只执行一次。

package org.mlinge.s10;
     
    public class ClassFactory{ 
    	
    	private enum MyEnumSingleton{
    		singletonFactory;
    		
    		private MySingleton instance;
    		
    		private MyEnumSingleton(){//枚举类的构造方法在类加载是被实例化
    			instance = new MySingleton();
    		}
     
    		public MySingleton getInstance(){
    			return instance;
    		}
    	} 
     
    	public static MySingleton getInstance(){
    		return MyEnumSingleton.singletonFactory.getInstance();
    	}
    }
     
    class MySingleton{//需要获实现单例的类，比如数据库连接Connection
    	public MySingleton(){} 
    }

ClassFactory.getInstance()