设计模式系列之——单例模式
单例模式在日常的开发中是比较常见的（其实本系列博客仅仅介绍在开发中常见的几种设计模式）
简单的了解下概念，单例模式：就是采用一定的方式，保证整个软件系统中，某个类只存在一个对象的实例。并且该类只提供一个取得其对象的实例的静态方法
单例模式常见的有八种方式：
①饿汉式-静态常量-要求会用
②饿汉式-静态代码块-要求会用
③懒汉式-线程不安全-要求了解
④懒汉式-线程安全，同步方法-要求了解
⑤懒汉式-线程安全，同步代码块-要求了解
⑥双重检查-要求会用
⑦静态内部类-要求会用
⑧枚举-要求会用
下面会对这八种方式一一进行详细的讲解
第一种方式：饿汉式-静态常量
1 //饿汉式-静态常量
2 class SingleTon {
3 //私有化构造器
4 private SingleTon() {
5 }
6
7 //在本地内部创建对象的实例
8 private final static SingleTon instance = new SingleTon();
9
10 //对外提供共有的静态方法，返回实例对象
11 public static SingleTon getInstance() {
12 return instance;
13 }
14 }
这种方式很简单粗暴，上来就是直接创建对象的实例，然后通过静态方法返回该对象的实例，注意构造器一定要私有化，不然外部能new那就不是单例了
优缺点说明
优点：写法简单，在类装载的时候就完成了实例化。避免了线程同步问题
缺点：在类装载的时候就完成了实例化，没有达到lazy loading的效果。如果至始至终都么有使用过这个类，则会造成内存的浪费
结论：这种单例模式可用，可能造成内存浪费
第二种方式：饿汉式-静态代码块
1 //饿汉式-静态代码块
2 class SingTon_static_final {
3 private static SingTon_static_final instance;
4 //私有化构造器
5 private SingTon_static_final() {}
6 //静态代码块-在静态代码块中创建单例对象
7 static {
8 instance = new SingTon_static_final();
9 }
10 //对外提供共有的静态方法，返回实例对象
11 public static SingleTon getInstance() {
12 return instance;
13 }
14 }
这种方式甚至比静态方法还要简单，在类被加载的时候就将实例生成好了
优缺点说明
优点：和静态常量方式类似。只不过是将实例化的过程放在了静态代码块中，也是在类装载的时候就初始化类的实例
结论：这种单例模式可用，可能造成内存浪费
第三种方式：懒汉式-线程不安全
1 class SingleTon {
2 private static SingleTon instance;
3 //私有化构造器
4 private SingleTon() {
5 }
6 //提供一个公共的静态的方法，当使用到该方法的时候才回去创建该类的实例--即懒汉式
7 public static SingleTon getInstance() {
8 if (instance == null) {
9 instance = new SingleTon();
10 }
11 return instance;
12 }
13 }
很显然这种方式是线程不安全的
优缺点说明
优点：起到了lazy loading的目的
缺点：但是只能是在单线程下使用。如果在多线程下使用，那么就会出现这样的情况，一个线程进入了 if (instance == null) ，但是还没有来得及继续往下面执行，这个时候另一个线程进来了，也因为前面一个线程还没有执行new SingleTon所以这个时候instance仍然是null这样就会有多个线程去执行new SingleTon，这样就会产生多个实例。所以在多线程情况下这个方式是不可以使用的，即非线程安全的
结论：在实际开发中，不要使用这种方式
第四种方式：懒汉式-线程安全-同步方法
1 class SingleTon {
2 private static SingleTon instance;
3 //私有化构造器
4 private SingleTon() {}
5 //提供一个公共的静态的方法，当使用到该方法的时候才回去创建该类的实例--即懒汉式
6 public static synchronized SingleTon getInstance() {
7 if (instance == null) {
8 instance = new SingleTon();
9 }
10 return instance;
11 }
12 }
这种只要看到synchronize同步的是方法就知道，这种方式效率一定是很低的，但是实际上这种方式并不是线程安全的，总之不推荐
优缺点说明
优点：解决了线程不安全问题
缺点：效率太低了。因为每个线程在获取类的实例的时候，执行getInstance()方法的时候都要进行同步。而其实这个方法只执行一次就够了，后面想要获得该方法的实例直接return就行了。方法进行同步效率太低
结论：在实际开发中，不推荐使用这种方式
第五种方式：懒汉式-线程安全-同步代码块
1 class SingleTon {
2 private static SingleTon instance;
3 //私有化构造器
4 private SingleTon() {}
5 //提供一个公共的静态的方法，当使用到该方法的时候才回去创建该类的实例--即懒汉式
6 public static SingleTon getInstance() {
7 if (instance == null) {
8 Synchronized(SingleTon.class){
9 instance = new SingleTon();
10 }
11 }
12 return instance;
13 }
14 }
不推荐，实际这种方式并不是线程安全的
优缺点说明
缺点：这种同步并不能起到线程同步的作用
结论：不推荐使用
第六种方式：双重检查
1 //双重超检查
2 class SingleTon {
3 private static volatile SingleTon instance;
4 private SingleTon() {}
5 public static SingleTon getInstance() {
6 if (instance == null) {
7 synchronized (SingleTon.class) {
8 if (instance == null) {
9 instance = new SingleTon();
10 }
11 }
12 }
13 return instance;
14 }
15 }
私有化构造器，防止外部new实例，当线程A、B调用getInstance的时候，A和B同时到达了第一个if (instance == null) 然后A先进去了，这个时候B就只能在外面等待A线程执行完毕，A进来判断instance为null然后new一个实例，并将结果返回，这个时候B线程可以进来了但是这个时候他发现instance并不为空，那么就直接返回instance
优缺点说明
优点：完美解决lazy loading问题，保证了线程同步，同时保证了效率
结论：在实际开发中，推荐使用这种方式
第七中方式：静态内部类
1 class SingleTon { 2 private SingleTon() { 3 } 4 //写一个静态内部类，里面有一个静态属性：INSTANCT 5 private static class SingleTonInstance { 6 private static final SingleTon INSTANCT = new SingleTon(); 7 } 8 //提供静态的公告的方法，直接返回SingleTonInstance.INSTANCT 9 public static SingleTon getInstance() { 10 return SingleTonInstance.INSTANCT; 11 } 12 }
这种方式就是在类里面定义各个静态的内部类，这个静态的内部类里面定义并创建该类的实例对象。然后对外提供静态的方法，返回在静态内部类中创建的实例
优缺点说明
这种方式采用了类装载机制来保证初始化实例时候只有一个线程。
静态内部类方式在在SingleTon被装载的时候并不会立即实例化，而是在需要实例化的时候调用getInstance()方法，才会装载SingleTonInstance类，从而完成了SingleTonInstance的实例化
类的静态属性只会在类被第一次加载的时候才会被初始化，所以在这里JVM帮助我们保证了线程的安全（JVM在装载类的时候是线程安全的）
第八中方式：枚举
1 //使用枚举可以实现单例 2 enum SingleTon { 3 //属性 4 INSTANCE; 5 public void sayOk() { 6 System.out.println("OK"); 7 }
优缺点说明
优点：借助JDK1.5添加的枚举来实现单例模式。不仅避免多线程同步问题，而且还能防止反序列化重新创建新的对象
结论：在实际开发中，推荐使用这种方式
总结：
①单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建和销毁的对象，使用单例模式可以提高系统性能
②当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用new
③单例模式的使用场景：需要频繁的进行创建和销毁对象、创建对象时耗时过多或者是消耗资源过多（即：重量级对象），但是又是经常用到的对象、工具类对象、频繁访问数据库或者是文件的对象（比如数据源、session工厂等）
