设计模式之单例设计模式

单例模式

单例模式（Singleton Pattern）是 Java 中最常见的设计模式之一。这种类型的设计模式属于创建型模式，它提供了
一种创建对象的最佳方式。

单利模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。该类还提供了一种访问它
唯一对象的方式，其他类可以直接访问该方法获取该对象实例，而不需要实例化该类的对象。

特点

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

优点

1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例。
2、避免对资源的多重占用（比如写文件操作）。

应用场景

1、网站的计数器
2、应用程序的日志应用
3、数据库连接池设计
4、多线程的线程池设计

创建方式

饿汉式

这里我们创建一个对象

public class SingleModel {

    private static  SingleModel instance = new SingleModel();

    // 构造函数私有

    private SingleModel(){}

    // 获得唯一的单例

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

测试是否是同一个

  // 获得对象
        SingleModel singleModel1 = SingleModel.getInstance();
        SingleModel singleModel2 = SingleModel.getInstance();
        if(singleModel1 == singleModel2){
            System.out.println("OK,家人们,我宣布个事!!!");
        }else{
            System.out.println("独立宣言!!!");
        }

结果:
OK,家人们,我宣布个事!!!

单例模式有多种创建方式，这一种创建方式没有特别的问题，但是程序启动就需要创建对象，不管你用不用到对象，都
会创建对象，都会消耗一定内存。

懒汉式

懒汉式有这些特点：
1、延迟加载创建，也就是用到对象的时候，才会创建
2、线程安全问题需要手动处理(不添加同步方法，线程不安全，添加了同步方法，效率低)
3、实现容易

public class SingleModel {

    private static  SingleModel instance;

    // 构造函数私有

    private SingleModel(){}

    // 获得唯一的单例

    public static SingleModel getInstance(){
        if(instance == null){
            instance = new SingleModel();
        }
        return instance;
    }
}

这种情况下,线程事实上是不安全的,因为如果说有两位同学同时操作的话,那么会导致创建出两个对象,这就违背了我们的初衷.
索引我尝试加上一个同步锁.

    public static synchronized  SingleModel getInstance(){
        if(instance == null){
            instance = new SingleModel();
        }
        return instance;
    }

这么做,我们解决了问题,但是同时也降低了效率.因为都要排队拿锁,效率可以说是相当的低了.
那么如何保证在线程安全的情况下,保证效率呢?
我们可以采用双锁机制.

  public static  SingleModel getInstance(){
        if(instance == null){
            // 同步锁
            synchronized (SingleModel.class){
                //这里需2次判空
                if(instance==null){
                    instance = new SingleModel();
                }
            }
            instance = new SingleModel();
        }
        return instance;
    }

为什么要判断两次呢?（敲黑板!!!）
我们有张三 李四 两位同学,张三同学进来了new 了一个,这时候不判断的话,李四也会new一个,就不安全了.

性能比较

单例情况下吃的内存:

  Set<SingleModel> list = new HashSet<>();
        SingleModel model = SingleModel.getInstance();
        list.add(model);
        for(int i = 0 ; i < 100000 ; i++){
            SingleModel instance = SingleModel.getInstance();
            if(model != instance){
                list.add(instance);
            }
        }
        System.out.println(list.size());

这里的size只有1,去掉构造方法中的private会有100001个.
如果用ramusageestimator.sizeof(list)来计算吃的内存,单例只有90-100个字节,而new 则会吃100W左右的字节的内存,可想而知!