简单的单例模式

    什么是单例模式，顾名思义：就是保证类在内存中只有一个对象。

应用实例：

1、一个政党党只能有一个领导人。

2、Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。

3、一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。
 

应用场景：

 1、要求生产唯一序列号。

2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。

3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

实现

     话不多说，接下来就讲讲如何实现单例模式。

1、单例类只能有一个实例。

2、单例类必须自己创建自己的唯一实例。

3、单例类必须给所有其他对象提供这一实例。

①饿汉式

package singleton;

/**
 * @Author：Hezhen
 * @Date:2021/11/26
 * @Describe:饿汉式单例（该模式的特点是类一旦加载就创建一个单例，
 * 保证在调用 getInstance 方法之前单例已经存在了。）
 */
public class HungrySingleton {
    private static final HungrySingleton instance=new HungrySingleton();
    private HungrySingleton(){

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

这是比较常见的写法，在类加载的时候就完成了实例化，避免了多线程的同步问题。当然缺点也是有的，因为类加载时就实例化了，没有达到Lazy Loading (懒加载) 的效果，如果该实例没被使用，内存就浪费了。

②懒汉式（终极版）

package singleton;

import java.lang.reflect.Constructor;

/**
 * @Author：Hezhen
 * @Date:2021/11/26
 * @Describe:如果编写的是多线程程序，则不要删除上例代码中的关键字 volatile 和 synchronized，
 * 否则将存在线程非安全的问题。如果不删除这两个关键字就能保证线程安全，但是每次访问时都要同步，
 * 会影响性能，且消耗更多的资源，这是懒汉式单例的缺点。
 */
public class LazySingleton {
    private static volatile LazySingleton instace=null;//保证instance在所有线程中同步
    private LazySingleton() {
       
        }
    
    }//避免类在外部被实例化！！

    private volatile static LazySingleton LazySingleton ;

    public static LazySingleton getInstance() {
        //双重检测锁模式的懒汉式单例 DCL懒汉式
        if (LazySingleton == null) {
            synchronized (LazySingleton.class) {
                if (LazySingleton == null) {
                    LazySingleton = new LazySingleton();//不是原子性操作
                    /**
                     * 会出现指令重排，避免这个要加volatile
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个对象指向这个空间
                     * 123
                     * 132  A
                     *      B//此时LazySingleton还没有完成构造
                     */
                }
            }
        }

        return LazySingleton;
    }

 
}

这种写法用了两个if判断，也就是Double-Check，并且同步的不是方法，而是代码块，效率较高。为什么要做两次判断呢？这是为了线程安全考虑，还是那个场景，对象还没实例化，两个线程A和B同时访问静态方法并同时运行到第一个if判断语句，这时线程A先进入同步代码块中实例化对象，结束之后线程B也进入同步代码块，如果没有第二个if判断语句，那么线程B也同样会执行实例化对象的操作了。
 

另外的思路：

1.静态内部类

 * @Author：Hezhen
 * @Date:2021/11/26
 * @Describe:静态内部类
 */
public class Hoder {
    private Hoder() {
    }
    public  static  Hoder getInstance(){
        return InnerClass.HODER;
    }
    public static class InnerClass {
        private static final Hoder HODER = new Hoder();

    }
}

    这种静态内部类方式在Hoder类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载InnerClass类，从而完成对象的实例化。同时，因为类的静态属性只会在第一次加载类的时候初始化，也就保证了InnerClass中的对象只会被实例化一次，并且这个过程也是线程安全的。
 

单例模式的优缺点

1. 优点：单例类只有一个实例，节省了内存资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能；单例模式可以在系统设置全局的访问点，优化和共享数据，例如前面说的Web应用的页面计数器就可以用单例模式实现计数值的保存。

2. 缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。