1，概念

确保有一个类只有一个实例，并提供一个全局访问点。

spring中的单例模式只保证了后半句话，没有从构造器级别去控制单例。

2，场景

1）场景

单例模式只允许创建一个对象，因此节省内存，加快对象访问速度。
使用单例可以减轻加载的负担、缩短加载的时间、提高加载的效率，但并不是所有地方都适用于单例，简单来说，单例主要适用于以下三个方面：

1>控制资源的使用，通过线程同步来控制资源的并发访问；

2>控制实例的产生，以达到节约资源的目的；

资源共享的情况下，避免由于资源操作时导致的性能或损耗等。如上述中的日志文件，应用配置。

3>控制数据的共享，在不建立直接关联的条件下，让多个不相关的进程或线程之间实现通信

控制资源的情况下，方便资源之间的互相通信。如线程池等。

2）使用

1. 需要频繁实例化然后销毁的对象。
2. 创建对象时耗时过多或者耗资源过多，但又经常用到的对象。
3. 有状态的工具类对象。
4. 频繁访问数据库或文件的对象。

3）举例

1. 外部资源
   每台计算机有若干个打印机，但只能有一个PrinterSpooler，以避免两个打印作业同时输出到打印机。内部资源：大多数软件都有一个（或多个）属性文件存放系统配置，这样的系统应该有一个对象管理这些属性文件
2. Windows的Task Manager（任务管理器）
   是很典型的单例模式（这个很熟悉吧），想想看，是不是呢，你能打开两个windows task manager吗？ 不信你自己试试看哦~
3. windows的Recycle Bin（回收站）
   是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。
4. 网站的计数器
   一般也是采用单例模式实现，否则难以同步。
5. 应用程序的日志应用
   一般都何用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
6. Web应用的配置对象的读取，一般也应用单例模式，这个是由于配置文件是共享的资源。
7. 数据库连接池的设计
   一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，因为何用单例模式来维护，就可以大大降低这种损耗。
8. 多线程的线程池设计
   一般也是采用单例模式，这是由于线程池要方便对池中的线程进行控制。
9. 操作系统的文件系统
   也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统。
10. HttpApplication
    也是单例的典型应用。熟悉ASP.Net(IIS)的整个请求生命周期的人应该知道HttpApplication也是单例模式，所有的HttpModule都共享一个HttpApplication实例.
11. 服务器配置的统一读取
    该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息。这种方式简化了在复杂环境下的配置管理。

3，优缺点

优

①全局变量的替换

单件可以延迟实例化（没有全局变量的缺点）。

②保障了对象的唯一性

避免了对共享资源的多重占用。
解决了多个实例引发的问题：如：程序的行为异常、资源使用过量、不一致的结果。无论别的类中建立了多少个Single实例，都只在内存中有的一个Single实例。

缺

①不适用于变化的对象

如果同一类型的对象总是要在不同的场景发生变化，单例模式就会引发数据的错误，不能保存彼此的状态。

②滥用单例模式

如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；
如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。

4，实现

1）设计模式实现

提供这个实例的全局访问点，当需要实例时，通过查询单件类，返回单个实例。

①将构造函数私有化。

为了避免其它程序过多建立该类对象，先禁止其他程序建立该类对象。

②在类中创建一个本类对象。

为了其他程序可以访问到该类对象，在本类中，自定义一个对象。

③提供一个方法获取到该对象。

为了方便其他程序对自定义对象访问，可以对外提供一些访问方式。
（引用自 黑马程序员 ）

5，代码

1）懒汉式（不推荐）

①概念

Singleton类进内存时，对象还没有存在。对象是方法被调用时，才初始化，也叫做对象的延时调用。
利用双重检查加锁（double-checked locking)

②场景

需要外部传参才能创建对象时使用。
使用时注意线程 安全问题。

③优缺点

优点：
避免了饿汉式的那种在没有用到的情况下创建事例，资源利用率高，不执行getInstance()就不会被实例，可以执行该类的其他静态方法。
缺点：
懒汉式在单个线程中没有问题，但多个线程同事访问的时候就可能同事创建多个实例，而且这多个实例不是同一个对象，虽然后面创建的实例会覆盖先创建的实例，但是还是会存在拿到不同对象的情况。解决这个问题的办法就是加锁synchonized，第一次加载时不够快，多线程使用不必要的同步开销大。

④实现

双重校验锁（Double Check Lock，DCL）

package Singleton;

/**
 * 懒汉式
 * Singleton类进内存时，对象还没有存在。对象是方法被调用时，才初始化，也叫做对象的延时调用。
 * 利用双重检查加锁（double-checked locking)
 * @author luo
 */
class Singleton {
	private Singleton() {
	}
	/**
	 * volatile关键词确保：当instance变量被初始化成Singleton实例时，多个线程正确地处理instance变量
	 */
	private volatile static Singleton instance = null;
	/**
	 * 双重检查加锁
	 * 首先检查是否实例已经创建了，如果尚未创建，才进行同步区块。
	 * 这样只有第一次会同步。
	 * @return
	 */
	public static Singleton getInstance() {
		if (null == instance) {//在instance已经实例化后下次进入不必执行synchronized (Singleton.class)获取对象锁，从而提高性能
			synchronized (Singleton.class) {
				// 加锁，只有第一次才彻底执行
				if (instance == null) {
					//进入区块后，再检查一次，如果仍是null，才创建实例
					instance = new Singleton();
				}
			}
		}
		return instance;

	}

	/*
	 * 验证
	 */
	private String name;

	public void setName(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}
}

1.给Singleton 分配内存
2.调用Singleton 的构造函数，初始化成员字段
3.将instance 对象指向分配的内存空间（此时instance 就不是null 了）

jdk 1.5 以后java 编译器允许乱序执行 。所以执行顺序可能是1-3-2 或者 1-2-3。如果是前者先执行3 的话，切换到其他线程，instance 此时 已经是非空了，此线程就会直接取走instance ，直接使用，这样就回出错。DCL 失效。解决方法 SUN 官方已经给我们了。将instance 定义成 private volatile static Singleton instance = null 即可

2）饿汉式（推荐）

①概念

先初始化对象。Singleton类一进内存就加载对象。

②场景

不需要外部传参使用。使用比较简单，比懒汉式常用。

③优缺点

优点
1.线程安全
2.在类加载的同时已经创建好一个静态对象，调用时反应速度快
缺点
资源效率不高，可能getInstance()永远不会执行到，但执行该类的其他静态方法或者加载了该类（class.forName)，那么这个实例仍然初始化

④实现

package Singleton;

public class Main {

	public static void main(String[] args) {	
		
		Singleton1 s11 = Singleton1.getInstance();
		Singleton1 s12 = Singleton1.getInstance();

		s11.setName("饿汉式单件");
		System.out.println(s12.getName());// 说明s11 s12指向同一个对象
	}
}

package Singleton;
/**
 * 饿汉式
 * 先初始化对象。Singleton类一进内存就加载对象。
 * @author luo
 */
class Singleton1 {
	private Singleton1() {
	}
	private static Singleton1 instance = new Singleton1();
	public static Singleton1 getInstance() {
		return instance;
	}
	/*
	 * 验证
	 */
	private String name;

	public void setName(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}
}

3）静态内部类（推荐）

①场景

一般采用饿汉式，若对资源十分在意可以采用静态内部类，不建议采用懒汉式及双重检测 。
采用内部类，在这个内部类里面去创建对象实例。这样的话，只要应用中不使用内部类，JVM 就不会去加载这个单例类，也就不会创建单例对象，从而实现懒汉式的延迟加载和线程安全。

②优缺点

优点
资源利用率高，不执行getInstance()不被实例，可以执行该类其他静态方法
缺点
第一次加载时反应不够快

③实现

public class Singleton{
    //内部类，在装载该内部类时才会去创建单利对象
    private static class SingletonHolder{
        public static Singleton instance = new Singleton();
    }

    private Singleton(){}

    public static Singleton newInstance(){
        return SingletonHolder.instance;
    }

    public void doSomething(){
        //do something
    }
}

4）枚举单例

①概念

Effective Java中推荐了一种更简洁方便的使用方式，就是使用枚举。
默认枚举实例的创建是线程安全的.(创建枚举类的单例在JVM层面也是能保证线程安全的), 所以不需要担心线程安全的问题，所以理论上枚举类来实现单例模式是最简单的方式。

②场景

线程安全，实现简单。
反序列化的时候，不会重新创建对象。

③实现

public enum Singleton{
    //定义一个枚举的元素，它就是Singleton的一个实例
    instance;

    public void doSomething(){
        // do something ...
    }    
}

使用：

public static void main(String[] args){
   Singleton singleton = Singleton.instance;
   singleton.doSomething();
}

④反序列化

要杜绝单例对象在反序列化时重新生成对象，那么必须加入如下方法：

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

如果你的单例类维持了其他对象的状态的话，因此你需要使他们成为transient的对象。
但是枚举单例，JVM对序列化有保证；反序列化时，不会生成新的实例。

5）使用容器模式实现单例

③概念

将众多单例模式类型注入到一个统一的管理类中，在使用时根据key 对应类型的对象。

②场景

便于管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。

③实现

public class SingletonManager{
	private static Map<String, Object> obMap = new hashMap<String,Object>();
	private SingletonManager(){}
	public static void registerService(String key, Object instance){
		if(!obMap.containKey(key)){
			obMap.put(key,instance);
		}
	}
	
	public static Object getService(String key){
		return obMap.get(key);
	}
}

5，对比

1）静态方法和非静态方法

①静态方法常驻内存，非静态方法只有使用的时候才分配内存？

这种说法错误，两者在内存中没有什么区别。

一般都认为是这样，并且怕静态方法占用过多内存而建议使用非静态方法，其实这个理解是错误的。

为什么会这样，先从内存分配开始说起：

托管堆的定义：对于32位的应用程序来说，应用程序完成进程初始化后，CLR将在进程的可用地址空间分配一块保留的地址空间，它是进程（每个进程可使用4GB）中可用地址空间上的一块内存区域，但并不对应任何物理内存，这块地址空间即是托管堆。

托管堆有分为多个区域，其中最重要的是垃圾回收堆（GC Heap）和加载堆（Loader Heap），GC
Heap用于存储对象实例，受GC管理；Loader Heap又分为High-Frequency Heap、Low-Frequency
Heap和Stub Heap，不同的堆上又存储不同的信息。Loader
Heap最重要的信息就是元数据相关的信息，也就是Type对象，每个Type在Loader Heap上体现为一个Method
Table（方法表），而Method Table中则记录了存储的元数据信息，例如基类型、静态字段、实现的接口、所有的方法等等。Loader
Heap不受GC控制，其生命周期为从创建到AppDomain卸载。（摘自《你必须知道的.Net》）

由此我们就明白了，静态方法和非静态方法，在内存里其实都放在Method Table里了，在一个类第一次被加载的时候，它会在Loader
Heap里把静态方法，非静态方法都写入Method Table中，而且Loader
Heap不受GC控制，所以一旦加载，GC就不会回收，直到AppDomain卸载

由此我们也明白了，静态方法和非静态方法，他们都是在第一次加载后就常驻内存，所以方法本身在内存里，没有什么区别，所以也就不存在”静态方法常驻内存，非静态方法只有使用的时候才分配内存“这个结论了。

②静态方法和非静态方法的区别？

调用速度上静态方法快一点，但区别不大。

在内存中的区别是，非静态方法在创建实例对象时，因为属性的值对于每个对象都各不相同，因此在new一个实例时，会把这个实例属性在GCHeap里拷贝一份，同时这个new出来的对象放在堆栈上，堆栈指针指向了刚才拷贝的那一份实例的内存地址上。而静态方法则不需要，因为静态方法里面的静态字段，就是保存在MethodTable里了，只有一份。

因此静态方法和非静态方法，在调用速度上，静态方法速度一定会快点，因为非静态方法需要实例化，分配内存，但静态方法不用，但是这种速度上差异可以忽略不计。

③场景

有线程安全问题，不要用静态方法。
一个方法和他所在类的实例对象无关，那么它就应该是静态的，否则就应该是非静态。因此像工具类，一般都是静态的。

2）非静态方法和单例

如果我们确实应该使用非静态的方法，但是在创建类时又确实只需要维护一份实例时，就需要用单例模式了。