唯一对象创建--单例模式

Java中类的实例化是通过new关键字实现的。单例模式目标和作用，就是保证任意时刻获取到的类对象都是同一个。也就是说只能使用一次new关键字创建对象，并把这个对象一直保留下来供程序全局使用。根据不同的使用场景，有三种不同的“单例模式”实现方式，下面分别进行讲解：

 

单线程下的单例模式

 

单线程下的单例模式是最常见的使用方式，但也经常被错误的用到多线程的情况下。其实现方式很简单：

为了限制外部使用new关键字，必须把构造方法设置为私有private；

为了把这个创建的对象一直保留下来，必须使用static的常量指向这个对象；

为了外部能使用这个对象，必须暴露一个public static的方法获取这个对象。

满足这三个条件，实现代码如下：

/**
 * 非线程安全单例模式
 * Created by gantianxing on 2017/10/17.
 */
public class Singleton0 {
 
    private static Singleton0 singleton0= null;
 
    private Singleton0(){
 
    }
 
    public static Singleton0 getInstance(){
        if(singleton0 == null){//多线程情况下，会创建多次
            singleton0 = new Singleton0();
        }
        return singleton0;
    }
}

在单线程的情况下，建议使用这种方式即可。有人会问现在的程序基本都是多线程 这种方式是不是没有价值了。其实不然，程序启动初始化的过程 可以理解为单线程，比如在@PostConstruct修饰的方法中首先调用Singleton0. getInstance ()方法，保证singleton0只被初始化一次，后续多个线程调用Singleton0. getInstance ()就不存在新对象创建，其实这种场景也可以使用第二种方式：

 

静态初始化型单例模式

 

在多线程环境里，使用第一种方式，会存在多次执行singleton0 = new Singleton0();

这段代码创建对象，破坏了单例模式的定义。换句话说，上述第一种方式 如果在单线程环境下是单例模式，如果在多线程环境下就是非单例模式，不能使用。下面我们来第二种单例模式实现，这种方式是静态变量初始化实现的单例模式：

 

/**
 * 静态初始化型 线程安全单例
 * Created by gantianxing on 2017/10/17.
 */
public class Singleton1 {
    private static final Singleton1 singleton1 = new Singleton1();
 
    private Singleton1(){
 
    }
 
    public static Singleton1 getInstance(){
        return  singleton1;
    }
}
 

 

这种方式没有第一次初始化线程安全问题，程序启动时已经完成第一次初始化，后续多线程下每次取到的都是统一实例。但如果初始化时间较长，可能会影响程序启动。如果初始化时间不长，建议是用这种方式，反之采用第三种方式 进行延迟初始化。

 

双重检查加锁（DCL）单例模式

 

其实第一种方式就是延迟初始化方式，在第一次使用的时候初始化，但在多线程的情况下无法保证只初始化一次。最简单的保证同步的方式，是直接在getInstance()方法前加synchronized，但在多线程环境下有不必要的性能开销，其实只要能保证第一次new创建对象时同步即可。具体实现方式：

public class Singleton2 {
 
    //注意必须是volatile修饰,保证多线程下数据的可见性
    private volatile static Singleton2 singleton2 = null;
 
    private Singleton2(){
 
    }
 
    public static Singleton2 getInstance(){
        if(singleton2 == null){//第一重检查
            synchronized(Singleton2.class){//类同步
                if(singleton2 == null){//第二重检查
                    singleton2 = new Singleton2();
                }
            }
        }
        return singleton2;
    }
}
 

 

双重检查加锁：第一步 第一次检查 检查singleton2是否为空；第二步 同步 如果为空执行同步代码块；第三步 第二次检查 由于有多个线程情况下有可能有多个线程等待锁，当第一个线程执行完成后，其他等待锁的线程都会依次执行，所以必须进程第二次检查，如果singleton2不为空，则不必再次创建。

 

另外，为了保证多线程之间数据及时可见性，必须使用 volatile修饰成员变量singleton2。

 

这就是经典的双重检查加锁实现，这里的使用的synchronized加锁，当然也可以使用Lock新锁api。这种实现方式可以在多线程环境下，对单例对象进行延迟实例化。

 

延长初始化占位类

 

 

延长初始化占位类：是对第二种方式的一种延迟初始化版本，具体是采用静态内部类的静态变量进行初始化。其原理是利用首次访问静态内部类时，只有一个线程加载该内部类，从而保证线程安全，具体实现如下：

public class Singleton4 {
 
   public class Singleton4 {
    private static class InnerHolder{
        public static Singleton4 singleton4 = new Singleton4();
    }
    private Singleton4(){

    }
    public static Singleton4 getInstance(){
        return InnerHolder.singleton4;
    }
}

这种延迟初始化单例模式比第三种DCL方式更加优雅，而且性能更好。在多线程环境下，建议使用这种方式。

 

关于java中四种常见的单例模式实现方式，以及使用场景就总结到这里，可以根据项目具体情况灵活选择。

 

最后提下，单例模式不仅仅用来创建一个普通对象，同样可以用于创建单例的Map、List等。

评论

2 楼 moon_walker 2017-10-18  

somefuture 写道

写的不错 不过现在流行的单利模式是用枚举

枚举我理解其实跟第二种方式类似，都属于静态初始化，在程序启动时就已经初始化了，所以没列出来。如果要延迟初始化，还是得使用第三种方式。

1 楼 somefuture 2017-10-18  

写的不错 不过现在流行的单利模式是用枚举