23种设计模式之单例模式

基本单例模式实现

模式目的：通过该设计模式实现在一定范围内只存在一个该类的实例对象。
实现原理：通过私有构造方法达到无法外界创建新对象，声明静态私有的对象以及公有静态的getInstance()方法使外界可获得该对象。
相关注意：存在多线程问题。

package _1_单例模式;

public class Singleton {
    //1、声明静态私有对象
    private static Singleton singleton = null;

    //2、将构造函数改变成私有的
    public Singleton() {
    }

    //3、生成一个静态的公有方法
    /**
     * 存在多线程问题
     * @return
     */
    public static Singleton getInstance(){
        if (singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

基于多线程优化

1、同步锁法

package _1_单例模式;

public class Singleton_1 {
    private static Singleton_1 singleton_1 = null;

    public Singleton_1() {
    }

    /**
     * 第一种方式：
     * 同步锁：可行，但是比较耗资源
     * @return
     */
    public static synchronized Singleton_1 getInstance(){
        if (singleton_1 == null){
            singleton_1 = new Singleton_1();
        }
        return singleton_1;
    }
}

2、先行对象法

package _1_单例模式;

public class Singleton_2 {
    private static Singleton_2 singleton_2 = new Singleton_2() ;

    public Singleton_2() {
    }

    /**
     * 第二种方式：
     * 先行对象：可行，对象不管使不使用都存在，比较耗资源
     * @return
     */
    public static Singleton_2 getInstance(){
        if (singleton_2 == null){
            singleton_2 = new Singleton_2();
        }
        return singleton_2;
    }
}

3、双重检查加锁法

package _1_单例模式;

public class Singleton_3 {
    //添加volatile关键字，使该对象线程间可用
    private volatile static Singleton_3 singleton_3 = null;

    public Singleton_3() {
    }

    /**
     * 第三种方式：
     * 双重检查加锁：可行，但是比较耗资源
     * @return
     */
    public static Singleton_3 getInstance(){
        if (singleton_3 == null){
            //添加同步锁：类上面
            synchronized (Singleton_3.class){
                if (singleton_3 == null){
                    singleton_3 = new Singleton_3();
                }
            }
        }
        return singleton_3;
    }
}