【3】单例模式

单例模式（Singleton pattern）

核心作用

保证一个类只有一个实例，并且提供一个访问该实例的全局访问点

五种实现单例模式的方式

1. 饿汉式(线程安全，调用效率高，不能延时加载)

package singlon;
//饿汉模式单例
public class Hungry{
    //一次性加载可能会浪费空间
    private byte[] data1=new byte[1024*1024];
    private byte[] data2=new byte[1024*1024];
    private byte[] data3=new byte[1024*1024];
    private byte[] data4=new byte[1024*1024];

    private Hungry(){
    }
    //初始就加载对象
    private final static Hungry HUNGRY=new Hungry();

    public static Hungry getInstance(){
        return HUNGRY;
    }
}

2. 懒汉式(线程安全，调用效率不高，能延时加载)

package singlon;
//懒汉式单例
public class LazyMan {
    private LazyMan() {
            System.out.println(Thread.currentThread().getName()+"OK");
    }

 private  static LazyMan LAZY_MAN;

    public static LazyMan getInstance1() {
        if (LAZY_MAN == null) {
            LAZY_MAN = new LazyMan();
        }
        return LAZY_MAN;
    }

    public static void main(String[] args) {
       for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                LazyMan.getInstance1();
            }).start();
        }
    }
}

---

3.双重检测技式(JWM底层内部模型原因，偶尔会出问题)

package singlon;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
//双重检测
public class DCL {

    private static boolean flag = false;

    private DCL() {
        synchronized (LazyMan.class) {

            if (flag == false) {
                flag = true;
            } else {
                throw new RuntimeException(("不要试图使用反射破坏异常"));
            }
            /*
            if(LAZY_MAN!=null){
                throw new  RuntimeException(("不要试图使用反射破坏异常"));
            }
            */

        }
    }

    //volatile关键字修饰的变量是被禁止重排序的。
    private volatile static DCL Dcl;

    //双重检测锁模式的  懒汉式单例，DCL懒汉式
    public static DCL getInstance() {
        if (Dcl == null) {
            //第一次检查， 先判断是否存在，不存在再加锁处理
            synchronized (LazyMan.class) {
                if (Dcl == null) {
                    //第二次检查，在同一个时刻加了锁的那部分程序只有一个线程可以进入
                    Dcl = new DCL();//不是一个原子操作
                    /*
                        1.分配内存空间
                        2.执行构造方法，初始化对象
                        3.把这个对象指向这个空间

                        主要的原因是重排序
                        *123
                        *132  A
                                B  //此时DCL还没有完成构造
                     */
                }
            }
        }
        return Dcl;
    }



    public static void main(String[] args) throws Exception {
//        DCL instance = DCL.getInstance();
//        DCL instance2 = DCL.getInstance();

        //反射
        Field flag = DCL.class.getDeclaredField("flag");
        flag.setAccessible(true);//破坏私有权限
        //获得反射对象，空参构造器
        Constructor<DCL> declaredConstructor = DCL.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);//无视私有的构造器
        DCL instance = declaredConstructor.newInstance();//通过反射创建对象

        flag.set(instance,false);

        DCL instance2 = declaredConstructor.newInstance();


        System.out.println(instance);
        System.out.println(instance2);
    }
}

4.静态内部类式(线程安全，调用效率高，能延时加载)

package singlon;

//静态内部类
public class Holder {
    //构造器私有
    private Holder() {
    }
    public static Holder getInstance(){
        return InnerClass.HODLER;
    }

    public static class InnerClass{
        //创建对象
        private static final Holder HODLER = new Holder();
    }
}

5.枚举单例(线程安全，调用效率高，不能延时加载)

package singlon;

import java.lang.reflect.Constructor;
//枚举单例
//反射不能破坏枚举
public enum EnumSingle {
    INSTANCE;
    public EnumSingle getInstance(){
        return INSTANCE;
    }
}

class Test{
    public static void main(String[] args) throws Exception {
        EnumSingle instance1 =EnumSingle.INSTANCE;
//        EnumSingle instance2 =EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor=EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);//无视私有的构造器
        EnumSingle instance2 = declaredConstructor.newInstance();//通过反射创建对象

        System.out.println(instance1);
        System.out.println(instance2);
    }
}

单例模式的优点

 提供了对唯一实例的受控访问。因为单例类封装了它的唯一实例，所以它可以严格控制客户怎样以及何时访问它，并为设计及开发团队提供了共享的概念。
 由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象，单例模式无疑可以提高系统的性能。
 允许可变数目的实例。我们可以基于单例模式进行扩展，使用与单例控制相似的方法来获得指定个数的对象实例。

单例模式的缺点

 由于单例模式中没有抽象层，因此单例类的扩展有很大的困难。
 单例类的职责过重，在一定程度上违背了“单一职责原则”。因为单例类既充当了工厂角色，提供了工厂方法，同时又充当了产品角色，包含一些业务方法，将产品的创建和产品的本身的功能融合到一起。
 滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；现在很多面向对象语言(如Java、C#)的运行环境都提供了自动垃圾回收的技术，因此，如果实例化的对象长时间不被利用，系统会认为它是垃圾，会自动销毁并回收资源，下次利用时又将重新实例化，这将导致对象状态的丢失。

常见应用场景

1.windows的任务管理器，回收站
2.项目中谈配置文件的类
3.网站的计数器
4.spring中，每个Bean默认是单例的
5. servlet编程中，每个servlet是单例的