设计模式系列之——单例模式

单例模式在日常的开发中是比较常见的（其实本系列博客仅仅介绍在开发中常见的几种设计模式）

简单的了解下概念，单例模式：就是采用一定的方式，保证整个软件系统中，某个类只存在一个对象的实例。并且该类只提供一个取得其对象的实例的静态方法

单例模式常见的有八种方式：

①饿汉式-静态常量-要求会用

②饿汉式-静态代码块-要求会用

③懒汉式-线程不安全-要求了解

④懒汉式-线程安全，同步方法-要求了解

⑤懒汉式-线程安全，同步代码块-要求了解

⑥双重检查-要求会用

⑦静态内部类-要求会用

⑧枚举-要求会用

下面会对这八种方式一一进行详细的讲解

第一种方式：饿汉式-静态常量

//饿汉式-静态常量
class SingleTon {
    //私有化构造器
    private SingleTon() {
    }

    //在本地内部创建对象的实例
    private final static SingleTon instance = new SingleTon();

    //对外提供共有的静态方法，返回实例对象
    public static SingleTon getInstance() {
        return instance;
    }
}

这种方式很简单粗暴，上来就是直接创建对象的实例，然后通过静态方法返回该对象的实例，注意构造器一定要私有化，不然外部能new那就不是单例了

优缺点说明

　　优点：写法简单，在类装载的时候就完成了实例化。避免了线程同步问题

　　缺点：在类装载的时候就完成了实例化，没有达到lazy loading的效果。如果至始至终都么有使用过这个类，则会造成内存的浪费

　　结论：这种单例模式可用，可能造成内存浪费

第二种方式：饿汉式-静态代码块

//饿汉式-静态代码块
class SingTon_static_final {
    private static SingTon_static_final instance;
    //私有化构造器
    private SingTon_static_final() {}
    //静态代码块-在静态代码块中创建单例对象
    static {
        instance = new SingTon_static_final();
}
    //对外提供共有的静态方法，返回实例对象
    public static SingleTon getInstance() {
        return instance;
    }
}

这种方式甚至比静态方法还要简单，在类被加载的时候就将实例生成好了

优缺点说明

　　优点：和静态常量方式类似。只不过是将实例化的过程放在了静态代码块中，也是在类装载的时候就初始化类的实例

　　结论：这种单例模式可用，可能造成内存浪费

第三种方式：懒汉式-线程不安全

class SingleTon {
    private static SingleTon instance;
    //私有化构造器
    private SingleTon() {
    }
    //提供一个公共的静态的方法，当使用到该方法的时候才回去创建该类的实例--即懒汉式
    public static SingleTon getInstance() {
        if (instance == null) {
            instance = new SingleTon();
        }
        return instance;
    }
}

很显然这种方式是线程不安全的

优缺点说明

　　优点：起到了lazy loading的目的

　　缺点：但是只能是在单线程下使用。如果在多线程下使用，那么就会出现这样的情况，一个线程进入了 if (instance == null) ，但是还没有来得及继续往下面执行，这个时候另一个线程进来了，也因为前面一个线程还没有执行new SingleTon所以这个时候instance仍然是null这样就会有多个线程去执行new SingleTon，这样就会产生多个实例。所以在多线程情况下这个方式是不可以使用的，即非线程安全的

　　结论：在实际开发中，不要使用这种方式

第四种方式：懒汉式-线程安全-同步方法

class SingleTon {
    private static SingleTon instance;
    //私有化构造器
    private SingleTon() {}
    //提供一个公共的静态的方法，当使用到该方法的时候才回去创建该类的实例--即懒汉式
    public static synchronized SingleTon getInstance() {
        if (instance == null) {
            instance = new SingleTon();
        }
        return instance;
    }
}

这种只要看到synchronize同步的是方法就知道，这种方式效率一定是很低的，但是实际上这种方式并不是线程安全的，总之不推荐

优缺点说明

　　优点：解决了线程不安全问题

　　缺点：效率太低了。因为每个线程在获取类的实例的时候，执行getInstance()方法的时候都要进行同步。而其实这个方法只执行一次就够了，后面想要获得该方法的实例直接return就行了。方法进行同步效率太低

　　结论：在实际开发中，不推荐使用这种方式

第五种方式：懒汉式-线程安全-同步代码块

class SingleTon {
    private static SingleTon instance;
    //私有化构造器
    private SingleTon() {}
    //提供一个公共的静态的方法，当使用到该方法的时候才回去创建该类的实例--即懒汉式
    public static SingleTon getInstance() {
        if (instance == null) {
             Synchronized(SingleTon.class){
                 instance = new SingleTon();
            }
        }
        return instance;
    }
}    

不推荐，实际这种方式并不是线程安全的

优缺点说明

　　缺点：这种同步并不能起到线程同步的作用

　　结论：不推荐使用

第六种方式：双重检查

//双重超检查
class SingleTon {
    private static volatile SingleTon instance;
    private SingleTon() {}
    public static SingleTon getInstance() {
        if (instance == null) {
            synchronized (SingleTon.class) {
                if (instance == null) {
                    instance = new SingleTon();
                }
            }
        }
        return instance;
    }
}

私有化构造器，防止外部new实例，当线程A、B调用getInstance的时候，A和B同时到达了第一个if (instance == null) 然后A先进去了，这个时候B就只能在外面等待A线程执行完毕，A进来判断instance为null然后new一个实例，并将结果返回，这个时候B线程可以进来了但是这个时候他发现instance并不为空，那么就直接返回instance

优缺点说明

　　优点：完美解决lazy loading问题，保证了线程同步，同时保证了效率

　　结论：在实际开发中，推荐使用这种方式

第七中方式：静态内部类

class SingleTon {
    private SingleTon() {
    }
    //写一个静态内部类，里面有一个静态属性：INSTANCT
    private static class SingleTonInstance {
        private static final SingleTon INSTANCT = new SingleTon();
    }
    //提供静态的公告的方法，直接返回SingleTonInstance.INSTANCT
    public static SingleTon getInstance() {
        return SingleTonInstance.INSTANCT;
    }
}

这种方式就是在类里面定义各个静态的内部类，这个静态的内部类里面定义并创建该类的实例对象。然后对外提供静态的方法，返回在静态内部类中创建的实例

优缺点说明

　　这种方式采用了类装载机制来保证初始化实例时候只有一个线程。

　　静态内部类方式在在SingleTon被装载的时候并不会立即实例化，而是在需要实例化的时候调用getInstance()方法，才会装载SingleTonInstance类，从而完成了SingleTonInstance的实例化

　　类的静态属性只会在类被第一次加载的时候才会被初始化，所以在这里JVM帮助我们保证了线程的安全（JVM在装载类的时候是线程安全的）

第八中方式：枚举

//使用枚举可以实现单例
enum SingleTon {
    //属性
    INSTANCE;
    public void sayOk() {
        System.out.println("OK");
    }

优缺点说明

　　优点：借助JDK1.5添加的枚举来实现单例模式。不仅避免多线程同步问题，而且还能防止反序列化重新创建新的对象

　　结论：在实际开发中，推荐使用这种方式

总结：

①单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建和销毁的对象，使用单例模式可以提高系统性能

②当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用new

③单例模式的使用场景：需要频繁的进行创建和销毁对象、创建对象时耗时过多或者是消耗资源过多（即：重量级对象），但是又是经常用到的对象、工具类对象、频繁访问数据库或者是文件的对象（比如数据源、session工厂等）