设计模式(单例模式)

Jcon_

于 2017-03-28 22:48:02 发布

阅读量318

点赞数 1

分类专栏：设计模式文章标签：设计模式

本文链接：https://blog.csdn.net/Jerrcy_Fly/article/details/67675132

版权

设计模式专栏收录该内容

5 篇文章 0 订阅

订阅专栏

单例模式：确保一个类最多只有一个实例，并提供一个全局访问点。

关键要领：

①构造函数私有化(private) ②提供一个获取实例的静态方法

   
   package jcon.com.singleton_03;
/**
 * 单例模式
 * 懒汉式：线程不安全的写法
 * @author Jcon
 *
 */
public class Singleton1 {
	private static Singleton1 instance;
	
	private Singleton1(){//①私有化构造函数
		
	}
	
	public static Singleton1 getInstance(){//②提供一个获取实例的静态方法
		if (instance == null) {
			instance = new Singleton1();
		}
		return instance;
	}
}

单例模式的7种写法：

1. 饿汉模式

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

这种方式在类加载时就完成了初始化，所以类加载较慢，但获取对象的速度快。这种方式基于类加载机制避免了多线程的同步问题，但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到懒加载的效果。

2. 懒汉模式（线程不安全）

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

懒汉模式申明了一个静态对象，在用户第一次调用时初始化，虽然节约了资源，但第一次加载时需要实例化，反映稍慢一些，而且在多线程不能正常工作。

3. 懒汉模式（线程安全）

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

这种写法能够在多线程中很好的工作，但是每次调用getInstance方法时都需要进行同步，造成不必要的同步开销，而且大部分时候我们是用不到同步的，所以不建议用这种模式。

4. 双重检查模式（DCL）

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

这种写法在getSingleton方法中对singleton进行了两次判空，第一次是为了不必要的同步，第二次是在singleton等于null的情况下才创建实例。在这里用到了volatile关键字，不了解volatile关键字的可以查看Java多线程（三）volatile域这篇文章，在这篇文章我也提到了双重检查模式是正确使用volatile关键字的场景之一。
在这里使用volatile会或多或少的影响性能，但考虑到程序的正确性，牺牲这点性能还是值得的。 DCL优点是资源利用率高，第一次执行getInstance时单例对象才被实例化，效率高。缺点是第一次加载时反应稍慢一些，在高并发环境下也有一定的缺陷，虽然发生的概率很小。DCL虽然在一定程度解决了资源的消耗和多余的同步，线程安全等问题，但是他还是在某些情况会出现失效的问题，也就是DCL失效，在《Java并发编程实践》一书建议用静态内部类单例模式来替代DCL。

5. 静态内部类单例模式

        
        public class Singleton { 
 private Singleton(){
 }
 public static Singleton getInstance(){ 
 return SingletonHolder.sInstance; 
 } 
 private static class SingletonHolder { 
 private static final Singleton sInstance = new Singleton(); 
 } 
}

第一次加载Singleton类时并不会初始化sInstance，只有第一次调用getInstance方法时虚拟机加载SingletonHolder 并初始化sInstance ，这样不仅能确保线程安全也能保证Singleton类的唯一性，所以推荐使用静态内部类单例模式。

6. 枚举单例

        
        private Object readResolve() throws ObjectStreamException{
return singleton;
}

枚举单例的优点就是简单，但是大部分应用开发很少用枚举，可读性并不是很高，不建议用。

7. 使用容器实现单例模式

         
         public class SingletonManager { 
　　private static Map<String, Object> objMap = new HashMap<String,Object>();
　　private Singleton() { 
　　}
　　public static void registerService(String key, Objectinstance) {
　　　　if (!objMap.containsKey(key) ) {
　　　　　　objMap.put(key, instance) ;
　　　　}
　　}
　　public static ObjectgetService(String key) {
　　　　return objMap.get(key) ;
　　}
}