单例模式_的六种实现

第一种不考虑线程

这一种实现方式再多线程下不安全

package com.senchen365.design;

/**
 * 类名:Single01<br>
 * 作者:java菜鸟<br>
 * 功能:实现单例模式<br>
 * 时间:22:22<br>
 * 版本:1.0.0<br>
 */
public class Single_01 {
    //最简单的实现单例模式不考虑多线程下
    private static Single_01 mySig = null;

    //构造器私有化
    private Single_01() {
    }
    //外部调用静态方法获取实例对象  但是在多线程情况下会出错 if (mySig == null) 正好执行到这句后线程切换然后
    //下一个线程检查mySig对象是否为 null 返回 true
    public static Single_01 getMySig(){
        if (mySig == null){
            mySig = new Single_01();
        }
        return mySig;
    }
}

第二种（懒汉式）

用synchronized 关键字对静态方法修饰实现线程安全但是由于每一次执行方法都要加上一个同步锁，而加锁会耗费时间不推荐使用

package com.senchen365.design;

/**
 * 类名:Single02<br>
 * 作者:java菜鸟<br>
 * 功能:实现单例模式<br>
 * 时间:22:22<br>
 * 版本:1.0.0<br>
 */
public class Single_02 {
    //简单的实现单例模式考虑多线程下
    private static Single_02 mySig = null;

    private Single_02() {
    }

    /**
     * 只是在一的版本上面给方法加上了 synchronized 关键字不推荐使用因为每次程序运行到这个方法
     * 总是需要加上一个同步锁，而加锁是一件很耗时的操作，不是必要的情况下我们应当避免
     * @return
     */
    public static synchronized Single_02 getMySig(){
        if (mySig == null){
            mySig = new Single_02();
        }
        return mySig;
    }
}

第三种（加同步锁前后两次判断）

可行的方式一 双if代码操作麻烦容易出错

package com.senchen365.design;

/**
 * 类名:Single01<br>
 * 作者:java菜鸟<br>
 * 功能:实现单例模式<br>
 * 时间:22:22<br>
 * 版本:1.0.0<br>
 */
public class Single_04 {
    private static Single_04 mySig = null;

    private Single_04() {
    }   
    public static Single_04 getMySig(){
        //第一次进行判断
        if (mySig == null){
            synchronized (Single_04.class) {
                //第二次进行判断
                if (mySig == null) {
                    mySig = new Single_04();
                }
            }
        }
        return mySig;
    }
}

推荐的方式一 没有实现懒加载(lazy loading)：即使用该对象shi在创建该对象的实例，降低了内存的使用效率

package com.senchen365.design;

/**
 * 类名:Single01<br>
 * 作者:java菜鸟<br>
 * 功能:实现单例模式<br>
 * 时间:22:22<br>
 * 版本:1.0.0<br>
 */
public class Single_03 {
    private static final Single_03 mySig = new Single_03();

    private Single_03() {
    }

    public static  Single_03 getMySig(){
        return mySig;
    }
}

第五种（静态内部类实现单例模式）

推荐方式二 书写代码复杂 但是效果很好推荐使用

package com.senchen365.design;

/**
 * 类名:Single01<br>
 * 作者:java菜鸟<br>
 * 功能:实现单例模式<br>
 * 时间:22:22<br>
 * 版本:1.0.0<br>
 */
public class Single_Out05 {
    public Single_Out05() {
    }
    public static Single_inner05 getSingleInner(){
    //调用内部类属性
        return Single_inner05.single_inner05;
    }
    private static class  Single_inner05{
        private Single_inner05() {
        }
        private static final Single_inner05 single_inner05 = new Single_inner05();
    }
}

第六种（枚举实现单例模式）

强烈推荐方式

package com.senchen365.design;

/**
 * 类名:Single_06<br>
 * 作者:java菜鸟<br>
 * 功能:<br>
 * 时间:0:34<br>
 * 版本:1.0.0<br>
 */
public enum Single_06 {
    //因为枚举类构造器私有化 而枚举前面的参数INSTANCE就是Single_06唯一所实例化的对象
    //而且枚举类隐式的继承了Enum类实现了可序列化所以用来创建单个实例对象最好不过
    INSTANCE;

    //下面声明的属性和方法只是为了说明它可以有属性和方法能够成为一个健全的类而来使用
    
    public String str=new String("哈哈");
    
    public void anyMethod(){

    }
}

Effective Java一书中推荐使用枚举实现单例

总结

一般情况下，不建议使用第 1 种和第 2 种懒汉方式，建议直接使用第六种枚举方式，如果有特殊要求再根据实际需要来选择要采用的方式。