单例模式,就是在程序中只有一个实例。该类自己创建自己的对象,同时确保只有一个对象被创建。
其实现主要是:
- 将构造方法定义为private,这样确保只有该类可以获得唯一实例
- 提供一个静态的方法,用于获取实例,为空就创建一个否则返回。
实现方式
懒汉式
public class LazySingle {
private static LazySingle lazySingle;
//私有构造方法
private LazySingle() {
}
//只有在需要的时候去创建,如果有则返回,没有则新建
public static LazySingle getInstance(){
if(lazySingle == null ){
lazySingle = new LazySingle();
}
return lazySingle;
}
}
只有在使用的时候去创建,多线程下有问题,可能导致多个实例。可以通过添加synchronized解决问题,但是不能乱加,如果直接加在方法getInstance上,迫使每个线程在进入这个方法前,要先等其他线程调用完,从而保证了单例的有效,但是效率低。可以改为同步代码块的方式,但是并不能做到线程安全,也可能产生多个实例,需要再加一个空判断,然后就变成了双重校验的没事了。
饿汉式
public class HungarySingle {
//实例在初始化的时候就已经建好了
//没有线程安全的问题,但是浪费内存空间。
private static HungarySingle hungarySingle = new HungarySingle();
private HungarySingle() {
}
public static HungarySingle getInstance(){
return hungarySingle;
}
}
被加载的时候,实例一个对象用于引用,而且在整个生命周期只会被加载一次,所以保证单例。在类装载的时候就完成实例化。避免了线程同步问题,但是如果不适用这个类,会造成内存的浪费。
双重锁模式
public class DoubleLockSingle {
//对象在创建的时候可能重排序,避免在多线程访问下存在风险,保证在写操作没有完成之前不能调用读操作。
private volatile static DoubleLockSingle single;
private DoubleLockSingle(){}
//进行了两次的判断
public static DoubleLockSingle getInstance(){
//避免不要的实例
if(single == null ){
synchronized (DoubleLockSingle.class){
//避免多线程问题
if(single == null){
single = new DoubleLockSingle();
}
}
}
return single;
}
}
静态内部类模式
public class InnerSingle {
private static class Inner{
private static final InnerSingle single = new InnerSingle();
}
private InnerSingle(){}
//只有第一次调用getInstance方法时,虚拟机才加载 Inner 并初始化instance ,
// 只有一个线程可以获得对象的初始化锁,其他线程无法进行初始化,保证对象的唯一性
public static InnerSingle getInstance(){
return Inner.single;
}
}
只有在被调用的时候才加载,类似懒汉式的感觉
枚举单例
public enum SingleEnum {
INSTANCE;
//可以通过Singleton.INSTANCE进行操作
public static SingleEnum getInstance(){
return SingleEnum.INSTANCE;
}
}
可以防止反射创建单例,其他的方式可以通过校验位来实现。在私有构造方法中添加一个校验
也可以防止克隆情况下产生多个
场景
如果某个对象的产生需要消耗大量资源,为避免频繁的创建以及销毁对资源的浪费;或者某种对象只能存在一个