实现Singleton模式，需要要把构造器保持为私有的，并导出公有的静态成员，以便允许客户端能够访问该类的唯一实例。
- 饿汉式(Eager mode)：单例对象是个 final域，在类加载期间，就实例化一个对象交给自己的引用
instance，如：
// Singleton with Eager mode
public class SingletonA
{
//实例化一个对象交给自己的引用
private static final instance = new SingletonA();
//私有化构造器
private SingletonA(){}
//返回单例对象
public static SingletonA getInstance()
{
return instance;
}
}
- 懒汉式(Lazy mode)公有的成员是个静态工厂方法，在调用取得实例方法的时候才会实例化对象
- 懒汉第1式：
//Singleton with Lazy mode
public class SingletonB
{
private static instance;
private SingletonB(){}
public static SingletonB getInstance()
{
if(instance == null)
instance = new SingletonB();
return instance;
}
}
如果线程1进入了if语句，但还未实例化instance，此时，线程2访问到
getInstance的if判断，因为instance还未实例化，所以也进入if内部；于是线程1和线程2，最后创建了两个实例。
- 懒汉第2式：同步锁
public static synchronized SingletonB getInstance()
{
if(instance == null)
instance = new SingletonB();
return instance;
}
可以有效防止多线程在执行getInstance方法得到2个对象，但是：
只有在instance为null时，才必须要求同步。一旦singleton不为null，系统依旧花费同步锁开销
- 懒汉第3式：
public static SingletonB getInstance()
{
if(instance == null)//1
synchronized(SingletonB.class)//2
{
instance = new SingletonB();//3
}
return instance;
}
这种写法减少了锁开销，但是依旧可能创建了2个对象。
- 线程1执行到1挂起，线程1认为singleton为null
- 线程2执行到1挂起，线程2认为singleton为null
- 线程1被唤醒执行synchronized块代码，走完创建了一个对象
- 线程2被唤醒执行synchronized块代码，走完创建了另一个对象
- 懒汉第4式：双重锁定检查（DCL）
public static SingletonB getInstance()
{
if(instance == null)//1
synchronized(SingletonB.class)//2
{
if(instance == null)
{
instance = new SingletonB();//3
}
}
return instance;
}
看是没有问题，但在
instance = new SingletonB()这句中，却暗藏杀机，因为jvm在执行这句代码时，实际分为三步：开辟内存空间，赋值给引用，初始化数据。这是需要消耗时间。
- 懒汉最终式：volatile
volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。
//Singleton with Lazy mode
public class SingletonB
{
private static volatile instance;
private SingletonB(){}
public static SingletonB getInstance()
{
if(instance == null)//1
synchronized(SingletonB.class)//2
{
if(instance == null)
{
instance = new SingletonB();//3
}
}
return instance;
}
}
volatile变量具有synchronized 的可见性特性，但是不具备原子特性。这就是说线程能够自动发现volatile变量的最新值
- Lazy initialization holder class模式
根据JLS(Java Language Specification)中的规定，一个类在一个ClassLoader中只会被初始化一次，这点是JVM本身保证的
public class SingletonC
{
private static instance;
//私有化构造器
private SingletonC(){}
//返回单例对象
public static SingletonC getInstance()
{
return SingletonHolder.INSTANCE;
}
private static class SingletonHolder
{
//单例对象实例
static final SingletonC INSTANCE = new SingletonC();
}
}
- 这种写法仍然使用JVM本身机制保证线程安全问题
- 由于SingletonHolder是私有的，除了getInstance()之外没有办法访问它，因此它是懒汉式的
- 同时读取实例的时候不会进行同步，没有性能缺陷
- 也不依赖JDK版本
- 从其他途径屏蔽构造单例对象的方法
- 直接new单例对象
一般加入一个private或者protected的构造函数
- 通过反射构造单例对象
需要在ReflectPermission("suppressAccessChecks") 权限下使用安全管理器（SecurityManager）的checkPermission方法来限制这种突破。
一般来说，不会真的去做这些事情，都是通过应用服务器进行后台配置实现
- 通过序列化构造单例对象
单例对象有必要实现Serializable接口，则应当同时实现readResolve()方法，以保证反序列化的时候得到原来的对象
public class Singleton implements Serializable
{
private static class SingletonHolder
{
static final Singleton INSTANCE = new Singleton();
}
public static Singleton getInstance()
{
return SingletonHolder.INSTANCE;
}
//private的构造函数用于避免外界直接使用new来实例化对象
private Singleton() {
}
//readResolve方法应对单例对象被序列化
private Object readResolve() {
return getInstance();
}
}
- 单例与枚举
按照《Effective Java 第二版》中的说法：单元素的枚举类型已经成为实现Singleton的最佳方法。用枚举来实现单例非常简单，只需要编写一个包含单个元素的枚举类型即可。
public enum SingletonEnum
{
INSTANCE;
private String field;
public String getField()
{
return field;
}
public void setField(String field)
{
this.field = field;
}
@Override
public String toString()
{
return "SingletonEnum{" +
"field='" + field + '\'' +
'}';
}
}
- 自由序列化
- 保证只有一个实例(使用反射机制也无法多次实例化一个枚举量)
- 线程安全
Singleton Mode总结
- 优点
- 在内存中只有一个对象，节省内存空间
- 避免频繁的创建销毁对象，可以提高性能
- 避免对共享资源的多重占用
- 可以全局访问
- 适用场景
- 需要频繁实例化然后销毁的对象
- 创建对象时耗时过多或者耗资源过多，但又经常用到的对象。
- 有状态的工具类对象。
- 频繁访问数据库或文件的对象。
