1、定义
• 确保一个类只有一个实例，且自行实例化，并向整个系统提供这个实例，这个类称为单例类，同时提供一个唯一的访问方法。
2、要点
• 一个类只有一个实例
• 必须自行创建实例
• 必须自行向整个系统提供这个实例
3、何时选用单例模式
• 系统只需要一个实例对象
• 客户调用类的单个实例，只允许使用一个公共访问点
• 单例模式可扩展为多例模式，即一个类可以有一个实例共存
4、本质
• 控制实例的数量
5、单例模式实现方式
• 饿汉式
package com.eager.test;
/**
* 饿汉式单例模式
*/
public class EagerSingleton {
//4：定义一个静态变量来存储创建好的类实例
//直接在这里创建类实例，只会创建一次
private static final EagerSingleton instance=new EagerSingleton();
//1：私有化构造方法，好在内部控制创建实例的数目
private EagerSingleton()
{
}
//2：定义一个方法来为客户端提供类实例
//3：这个方法需要定义成类方法，也就是要加static
//这个方法里面就不需要控制代码了
public static EagerSingleton getInstance()
{
return instance;
}
}
说明：
1）static变量，在类加载的时候进行初始化
2）多个static变量，共享一块内存区域
3）饿汉式的一个缺点就是不管这个实例是否被使用，该实例都会被创建，会有一点点浪费内存
• 普通懒汉式
package com.lazy.test;
/**
* 普通懒汉单例模式
*/
public class CommonLazySingleton {
private static CommonLazySingleton instance=null;
//私有的构造方法，以便在内部控制创建实例的个数
private CommonLazySingleton()
{
}
//synchronized
public static CommonLazySingleton getInstance()
{
//如果没有值，说明还没有创建过实例，那就创建一个
//并把这个实例设置给instance
if(instance==null)
{
instance=new CommonLazySingleton();
}
//如果有值则直接使用
return instance;
}
}
说明：普通懒汉式虽然利用延迟加载，解决了需要使用实例时才创建，但是这种方式是线程不安全的，假如A线程走到20行，但是还没有走到22行进行创建instance，此时，线程B也很快判断出instance==null，就会出现线程不安全的现象。
• 双重检查加锁懒汉式
package com.lazy.test;
/**
* 双重检查锁定懒汉单例模式
*/
public class DoubleCheckLockingLazySingleton {
/**
* 对保存实例的变量添加volatile的修饰
*/
private volatile static DoubleCheckLockingLazySingleton instance = null;
private DoubleCheckLockingLazySingleton()
{
}
public static DoubleCheckLockingLazySingleton getInstance()
{
//先检查实例是否存在，如果不存在才进入下面的同步块
if(instance == null)
{
//同步块，线程安全的创建实例
synchronized(DoubleCheckLockingLazySingleton.class)
{
//再次检查实例是否存在，如果不存在才真的创建实例
if(instance == null)
{
instance = new DoubleCheckLockingLazySingleton();
}
}
}
return instance;
}
}
说明：
1）双重检查加锁方式解决了延迟加载与线程安全问题，但是用到了Java中的关键字volatile，被volatile修饰的变量的值，不会被本地线程所缓存，所以对该变量的读取都是从共享内存中读取，从而保证多线程的安全性。
2）Java1.4及以前版本中，很多JVM对于volatile关键字的实现有问题，会导致双重检查加锁的失败，因此双重检查加锁的机制只能用再Java5及以上版本
3）由于volatile关键字可能会哦ing比掉JVM中一些必要的代码优化，因此运行效率不高。所以没有特别的需要，不建议使用。所以双重检查加锁策略虽然可以解决问题，但是不建议大量采用。
• IoDH懒汉式
package com.lazy.test;
/**
* IoDH懒汉单例模式
*/
public class IoDHLazySingleton {
private IoDHLazySingleton()
{
}
/**
* 静态内部类，该内部类的实例与外部类的实例没有绑定关系，而且只有被调用才会装载，实现延迟加载
*
* 多个实例的static变量会共享同一块内存区域
*/
private static class HolderClass
{
private final static IoDHLazySingleton instance=new IoDHLazySingleton();
}
/**
* 提供给其他类获取唯一实例的方法
*/
public static IoDHLazySingleton getInstance()
{
return HolderClass.instance;
}
}
说明：利用静态内部类既实现了延迟加载，又实现了线程安全，因此推荐的使用方法之一即为此种方式。
• 枚举实现的饿汉式
package com.enum_test;
/**
* 使用枚举来实现单例模式的示例
*/
public enum SingletonEnum {
/**
* 定义一个枚举的元素,它就代表了SingletonEnum的一个实例
*/
INSTANCE;
/**
* 示意方法，单例可以有自己的操作
*/
public String print() {
System.out.println("Enum测试实例调用方法");
return "Enum单例模式测试";
}
// public static Singleton getInstance() {
// return INSTANCE;
// }
}
说明：
1）Java的枚举型实质上是功能齐全的类，可以有自己的属性和方法
2）Java的枚举型的基本思想是通过public static final 域为每个枚举常量导出实例对象的
3）因此，用枚举实现单例模式会更加简洁、方便、并且提供了序列化的机制，由JVM保证线程安全。