Java-这就是单例模式！

什么是单例模式

单例模式，自己负责创建自己的对象这个类提供了，一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。通俗的讲就是保证在整个应用程序的生命周期中只会被创建一次。

为什么需要使用单例模式

1.避免对象被不断的创建，消耗不必要的系统资源。
2.如果不使用单例，可能在某些程序运行的时候将会出现错误。下面举一个例子，证明如果不使用单例会使什么样子的。
定义一个ShareResources（共享资源）类

//共享资源
public class ShareResources {

    private String name = "SmileJosiah";

    public void setName(String name){
        this.name = name;
    }

    public String getName(){
        return name;
    }
}

//测试类
public class Demo {
    public static void main(String[] args) {
        ShareResources shareResources = new ShareResources();
        shareResources.setName("Bob");

        ShareResources shareResources1 =  new ShareResources();
        shareResources1.setName("Jack");

        //.... 但是这样改变了以后 这个共享的ShareResources中的name真的就是“Jack”吗？，答案显然不是
        //不管是修改为“Bob”还是“Jack”都是在对某一个具体的实例对象中的name进行了修改而已

        ShareResources shareResources2 = new ShareResources();
        System.out.println(shareResources2.getName());
    }
}

如何实现单例模式（七种方法）

• 饿汉式(线程安全，可以使用)

//饿汉式
public class HungarySingleton {
    private static HungarySingleton instance = new HungarySingleton();
    //私有化构造方法
    private HungarySingleton(){}

    public static HungarySingleton getInstance(){
        return instance;
    }
}

分析：饿汉式优点是，代码实现简单易懂。缺点是不能做到Lazy-loading（懒加载）的效果，如果我一直不需要用这个实例对象，那么它仍然会创建出来，显得有点浪费资源了。不过这点资源的浪费还是可以接受滴，关键是简单易写，效率高就完事儿了。

• 懒汉式(线程不安全，不推荐使用)

//懒汉式(线程不安全)
public class LazySingleton {

    private volatile static LazySingleton instance = null;

    private LazySingleton(){}

    public static LazySingleton getInstance(){
    //线程不安全就是发生在这个if这里哦
        if(instance == null){
            instance = new LazySingleton();
        }
        return instance;
    }
}

分析：懒汉式优点实现了Lazy-loading，解决了饿汉式中不完美的地方，但是却带来了一个更大的缺点。 缺点是这么写它线程都不安全了呀，当线程A执行到 if(instance == null)的时候，进入if条件中正在准备new LazySingleton()，线程B进入了if条件，当线程A创建完毕以后，线程B又创建了一个对象。所以这种写法是 线程不安全的。

• 懒汉式加锁（线程安全，效率低下 不推荐使用）

//使用加锁的懒汉式
public class SynchronizedLazySingleton {

    private volatile static SynchronizedLazySingleton instance = null;

    private SynchronizedLazySingleton(){}
    //加上锁，保证是能有一个线程进入该方法创建一个对象。
    //但是这中方式将整个方法都锁住了，效率极其低下
    public static synchronized SynchronizedLazySingleton getInstance(){
        if(instance == null) {
            instance = new SynchronizedLazySingleton();
        }
        return instance;
    }
}

分析：这种对getInstance()方法加锁。优点：实现了饿汉式不具备的Lazy-loading，解决了普通懒汉式的线程不安全的问题。缺点：效率低下，例如线程A执行getInstance()获得锁，进入if条件执行了创建对象得操作，但是如果了后面成千上万个线程，本来在线程A创建了对象实例后，后面得所有线程都应该不会再去获得锁资源直接返回。但是这种写法导致所有得线程都会去获取一遍锁资源。导致效率低下。可能有同学会说了，我这个synchronized加在 if 判断那里不久避免了效率低下得问题了吗？这个问题我们来看看

//比较上面的加锁方式，这次将锁的粒度变小一点
public class SynchronizedLazySingleton2 {

    private volatile static SynchronizedLazySingleton2 instance = null;

    private SynchronizedLazySingleton2(){}
    //这种方式依然是一种线程不安全的
    public static SynchronizedLazySingleton2 getInstance(){
        if(instance == null){
            synchronized (SynchronizedLazySingleton2.class){
                instance = new SynchronizedLazySingleton2();
            }
        }
        return instance;
    }
}

乍一看好像避免了上面效率低得问题，但是它却导致了新的问题——线程又不安全了。当线程A进入 if 条件获取到锁资源，准备创建instance得时候，线程B进入了 if 条件。当线程A创建完成后，释放锁资源。线程B获得锁资源，又可以创建实例对象了。不过只需将上面得程序稍微改改就可以是万无一失得了哦，你猜到了吗？(●’◡’●)

• 懒汉式双重检查（线程安全，推荐使用）

//双重检验锁实现单例模式
public class TwoCheckLockSingleton {
    private volatile  static TwoCheckLockSingleton instance = null;
    
    private TwoCheckLockSingleton(){}
    
    public static TwoCheckLockSingleton getInstance(){
        if(instance == null){
            synchronized (TwoCheckLockSingleton.class){
            //在这里多加了一个if判断
                if(instance == null){
                    instance = new TwoCheckLockSingleton();
                }
            }
        }
        return instance;
    }
}

分析：可以照着上面分析得思路，去自己分析一下为什么它是线程安全得呢？

• 静态匿名内部类（线程安全，推荐使用）

//内部类实现单例模式
public class InternalClassSingleton {

    private volatile static InternalClassSingleton instance = null;

    private static  class SingletonHandler{
        private static InternalClassSingleton internalClassSingleton = new InternalClassSingleton();
    }

    public static InternalClassSingleton getInstance(){
        return SingletonHandler.internalClassSingleton;
    }
}

分析：使用静态内部类，实现了Lazy-loading得效果，同时线程安全。静态内部类不会随着外部类得加载而加载，只有当静态内部类得静态成员被调用得时候才会进行加载，所以这样不仅保持了Lazy-loading还实现了线程安全（是由JVM自身保证了线程安全）

• 枚举（完美的方式）

//使用枚举的单例模式
public class EnumSingleton {

    public static EnumSingleton getInstance(){
        return Enum.INSTANCE.getInstance();
    }

    private enum Enum{
        INSTANCE;
        private EnumSingleton singleton;
        //关键，使用枚举类的构造方法创建对象实例
        Enum() {
            singleton = new EnumSingleton();
        }
        private EnumSingleton getInstance(){
            return singleton;
        }
    }
}

分析：大家可以参考CSDN-为什么我墙裂建议大家使用枚举来实现单例

总结

1.饿汉式：线程安全，并且代码简单，但是不能实现Lazy-loading的效果。
2.懒汉式：简单的懒汉式，实现了懒加载效果但是线程不安全；使用synchronized将方法加锁的懒汉式，虽然解决了线程安全问题但是效率低下。使用双重检查锁的懒汉式，保证了线程安全和Lazy-loading，虽然在代码上有点臃肿，但是总体而言推荐使用。
3.静态匿名内部类：延迟加载，减少内存开销。因为用到的时候才加载，避免了静态field在单例类加载时即进入到堆内存的permanent代而永远得不到回收的缺点
4.枚举：最完美的方式。不但能避免多线程同步的问题，而且还可以防止反序列化重新创建对象。但是失去了一些类的特性，而且还具有Lazy-loading

下一篇:Java-设计模式之模板方法模式