设计模式——单例模式

叁歲伎倆 2021-06-24 13:58 503阅读 0赞

# 1.什么是单例 #

单例 Singleton 是设计模式的一种，其特点是只提供唯一一个类的实例,具有全局变量的特点，在任何位置都可以通过接口获取到那个唯一实例; 具体运用场景如：

*  设备管理器，系统中可能有多个设备，但是只有一个设备管理器，用于管理设备驱动;
 *  数据池，用来缓存数据的数据结构，需要在一处写，多处读取或者多处写，多处读取;

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。简单来说使用单例模式可以带来下面几个好处：

*  对于频繁使用的对象，可以省略创建对象所花费的时间，这对于那些重量级对象而言，是非常可观的一笔系统开销；
 *  由于 new 操作的次数减少，因而对系统内存的使用频率也会降低，这将减轻 GC 压力，缩短 GC 停顿时间。

# 2. 单例模式的实现 #

一个类能返回对象一个引用(永远是同一个)和一个获得该实例的静态方法，通常使用getInstance。当getInstance被调用时，如果类持有的引用不为空就返回这个引用，如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用。

同时我们 还将该类的构造函数定义为私有方法，这样其他处的代码就无法通过调用该类的构造函数来实例化该类的对象，只有通过该类提供的静态方法来得到该类的唯一实例。

**需要注意的地方：**  
单例模式在多线程的场合下须小心使用，如果当唯一实例尚未创建时，有两个线程同时调用创建方法，那么它们同时没有检测到唯一实例的存在，从而同时各自创建了一个实例， 这样就有两个实例被构造出来，从而违反了单例模式中实例唯一的原则。

解决这个问题的办法是为指示类是否已经实例化的变量提供一个互斥锁(虽然这样会降低效率)。

**实现单利模式的原则和过程：**

*  单例模式：确保一个类只有一个实例，自行实例化并向系统提供这个实例
 *  单例模式分类：饿单例模式（类加载时实例化一个对象给自己的引用），懒单例模式（调用取得实例的方法如getInstance时才会实例化对象）（java中饿单例模式性能优于懒单例模式，c++中一般使用懒单例模式）
 *  单例模式要素：  
    \- a.私有构造方法  
    \- b.私有静态引用指向自己实例  
    \- c.以自己实例为返回值的公有静态方法

# 3.单例模式的优缺点 #

**优点：**

*  提供了对唯一实例的受控访问。 在单例模式中，活动的单例只有一个实例，对单例类的所有实例化得到的都是相同的一个实例
 *  由于在系统内存中只存在一个对象，因此可以节约系统资源，当需要频繁创建和销毁的对象时单例模式无疑可以提高系统的性能
 *  避免对共享资源的多重占用

**缺点：**

*  不适用于变化的对象，如果同一类型的对象总是要在不同的用例场景发生变化，单例就会引起数据的错误，不能保存彼此的状态
 *  由于单利模式中没有抽象层，因此单例类的扩展有很大的困难。
 *  单例类的职责过重，在一定程度上违背了“单一职责原则”。
 *  单例使用过多会造成一些问题：  
    1.为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；  
    2.如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。

# 4. 举个例子 #

一般采用饿汉式，若对资源十分在意可以采用静态内部类，不建议采用懒汉式及双重检测

## 4.1 饿汉式： ##

单例实例在类装载时就构建，急切初始化。（预先加载法）  
**优点 :**  
1.线程安全  
2.在类加载的同时已经创建好一个静态对象，调用时反应速度快

**缺点 :**  
资源效率不高，可能getInstance()永远不会执行到，但执行该类的其他静态方法或者加载了该类（class.forName)，那么这个实例仍然初始化

//饿汉式
    public class Singleton{ 
    	private Singleton(){ 
    	}
    	public static Singleton instance = new Singleton();
    	public Singleton getInstance{ 
    		return instance;
    	}
    }

## 4.2 懒汉式： ##

单例实例在第一次被使用时构建，延迟初始化。  
**优点：**  
避免了饿汉式的那种在没有用到的情况下创建事例，资源利用率高，不执行getInstance()就不会被实例，可以执行该类的其他静态方法。

**缺点：**  
懒汉式在单个线程中没有问题，但多个线程同事访问的时候就可能同时创建多个实例，而且这多个实例不是同一个对象，虽然后面创建的实例会覆盖先创建的实例，但是还是会存在拿到不同对象的情况。解决这个问题的办法就是加锁synchonized，第一次加载时不够快，多线程使用不必要的同步开销大。

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

## 4.3 双重检测： ##

**优点**  
资源利用率高，不执行getInstance()就不被实例，可以执行该类其他静态方法

**缺点**  
第一次加载时反应不快，由于java内存模型一些原因偶尔失败

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

## 4.4 静态内部类 ##

**优点**  
资源利用率高，不执行getInstance()不被实例，可以执行该类其他静态方法

**缺点**  
第一次加载时反应不够快

class Singleton{ 
    	private Singleton(){ 
    	}
    	//静态内部类
    	public static class SingletonHelp{ 
    		static Singleton instance = new Singleton();
    	}
    	public static Singleton  getInstance(){ 
    		return SingletonHelp.instance();
    	}
    }