单例模式 - Java实现

单例模式

单例模式具有的特点：

单例类只能有一个实例
单例类必须自己创建自己的唯一实例
单例类必须给其他对象提供这一唯一实例

保证类的对象在内存中的唯一性

1、饿汉式

public class Single1 {
     private static final Single1 s = new Single1();
     private Single1(){}
     public static Single1 getInstance(){
         return s;
     }
}

为什么方法是静态的：

不能new对象却想调用类中方法，方法必然是静态的，
静态方法只能调用静态成员，所以对象也是静态的。

为什么对象的访问修饰符是private，不能是public 吗？

不能，如果访问修饰符是Public，则Single.s也可以得到该类对象，这样就造成了不可控。

加载类的什么周期有关，static修饰的静态变量，类，在类加载时已经被初始化了，getInstance是在使用阶段操作，安全是有类加载机制保证

特点：线程安全，无法实现实例懒加载策略。

2、懒汉式

public class Single2 {
    private static Single2 s = null;
    private Single2() { }

    public static Single2 getInstance() {
        //两个线程同时进行if (s == null)判断，则都会进入if条件吗，就会创建对个实例
        if (s == null)
            s = new Single2();
        return s;
    }
}

懒汉式和饿汉式相比的区别就是懒汉式创建了延迟对象同时饿汉式的实例对象是被修饰为final类型。

优点：懒汉式的好处是显而易见的，它尽最大可能节省了内存空间。
缺点：在多线程编程中，使用懒汉式可能会造成类的对象在内存中不唯一，虽然通过修改代码可以改正这些问题，但是效率却又降低了。

总结：

懒汉式在面试的时候经常会被提到，因为知识点比较多，而且还可以和多线程结合起来综合考量。
饿汉式在实际开发中使用的比较多。

特点：线程不安全，实现了实例懒加载策略。

3、局锁式

public class Single3 {
    private static Single3 single3;
    private Single3() {}

    //synchronized修饰的是静态方法，锁类对象
    public synchronized static Single3 getInstance() {
        if (single3 == null)
            single3 = new Single3();
        return single3;
    }
}

特点：线程安全，且实现了懒加载策略，但是线程同步时效率不高（synchronized）。

4、静态代码块式

public class Single4 {
    private final static Single4 singleton4;
    private Single4() { }

    static {
        singleton4 = new Single4();
    }

    public static Single4 getInstance() {
        //使用之前将singleton4属性通过静态代码块实现
        return singleton4;
    }

    public static void main(String[] args) {
        //第一次调用Single4，JVM需要负责将Single4加载到内存中，在加载的过程处理静态代码块
        Single4.getInstance();
        //第二次调用Single4，JVM中已经存在Single4，直接使用getInstance
        Single4.getInstance();
    }
}

特点：线程安全，类主动加载时才初始化实例，实现了懒加载策略，且线程安全。

5、双重校验锁式

public class Single5 {
    private static volatile Single5 singleton5;
    private Single5() {}

    public  static Single5 getInstance() {
        if (singleton5 == null) {
            synchronized (Single5.class) {
                if (singleton5 == null) {
                    //内层if判断使用的时间（起作用时机）
                    //第一次两线程同时调用getInstance，都会进入外层if判断
                    //内层if判断是针对第二个进入synchronized代码块线程，此时第一个线程已经创建出对象
                    //第二个线程无需创建
                    singleton5 = new Single5();
                }
            }
        }
        return singleton5;
    }
}

特点：线程安全，且实现了懒加载策略，同时保证了线程同步时的效率。

但是volatile强制当前线程每次读操作进行时，保证所有其他的线程的写操作已完成。

volatile使得JVM内部的编译器舍弃了编译时优化，对于性能有一定的影响。

6、静态内部类式【推荐】

public class Single6 {
    private Single6() {}

    private static class SingletonHolder {
        private static final Single6 INSTANCE = new Single6();
    }

    public static Single6 getInstance() {
        return Single6.SingletonHolder.INSTANCE;
    }
}

静态代码块的思路是一样的

特点：线程安全，不存在线程同步问题，且单例对象在程序第一次 getInstance() 时主动加载 SingletonHolder 和其静态成员 INSTANCE，因而实现了懒加载策略。

7、枚举方式【推荐】

public class Single7 {
    private Single7() {}

    enum SingletonEnum {
        INSTANCE;

        private final Single7 singleton7;
        private SingletonEnum() {
            singleton7 = new Single7();
        }
    }

    public static Single7 getInstance() {
        return SingletonEnum.INSTANCE.singleton7;
    }
}

特点：线程安全，不存在线程同步问题，且单例对象在枚举类型 INSTANCE第一次引用时通过枚举的构造函数初始化，因而实现了懒加载策略。

这种方式是Effective Java作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，可谓是很坚强的壁垒啊。不过，由于JDK 1.5中才加入enum特性

参考链接

posted @ 2020-06-30 23:45 xtLLL 阅读(153) 评论(0) 收藏举报

刷新页面返回顶部

xtLLL