单例模式

定义：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

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

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

注意：

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

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

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

优点：

• 在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。

• 避免对资源的多重占用（比如写文件操作）。

缺点：

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

代码：

第一种方式（饿汉式线程安全）：

/**
 * 饿汉式
 * 类加载到内存后，就实例化一个单例，JVM保证线程安全
 * 简单实用，推荐使用！
 * 唯一缺点：不管用到与否，类装载时就完成实例化
 * Class.forName("")
 * （话说你不用的，你装载它干啥）
 */
public class Mgr01 {
	//定义一个静态实例
    private static final Mgr01 INSTANCE = new Mgr01();

	//这一步很重要，设置成私有的，别人不能调用
    private Mgr01() {};
	
	//如果别人想用只能调用getInstance方法
    public static Mgr01 getInstance() {
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        Mgr01 m1 = Mgr01.getInstance();
        Mgr01 m2 = Mgr01.getInstance();
        System.out.println(m1 == m2);
    }
}

第二种方式（懒汉式线程不安全）：

/**
 * lazy loading
 * 懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 */
public class Mgr03 {
	//不初始化INSTANCE
    private static Mgr03 INSTANCE;
	//不初始化就new不出来
    private Mgr03() {
    }
	//进行判断，为null了，在初始化 
    public static Mgr03 getInstance() {
        if (INSTANCE == null) {
			try {
            	Thread.sleep(1);
        	} catch (InterruptedException e) {
            	e.printStackTrace();
        	}
            INSTANCE = new Mgr03();
        } 
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
			//"->":这是lambda表达式,一种语法,可以简化代码,从java8开始支持lambda表达式
            new Thread(()->
                System.out.println(Mgr03.getInstance().hashCode())
            ).start();
        }
    }
}

执行过程：

• 多线程的时候，执行到if判断时，第一根线程在判断中，这是另一线程进来了，他比第一根快，他也进行判断，因为还没有new Mgr03，所以为null，这是他继续向下执行，执行到INSTANCE = new Mgr03();他new了一个Myr03，这时第一根线程执行完了，他也new了一个Myr03，这时就有两个INSTANCE对象，所以带来了更大的问题，怎么判断是否有两个呢，Mgr03.getInstance().hashCode()，每一个hashCode的码值是不一样的这里我们循环了100个，结果不一样就说明new出了多个INSTANCE，一样就没有，因为在执行的时候睡了1毫秒，码值就乱了，所以执行结果是不一样的

  

我们来看第三种方式怎么解决的

第三种方式（懒汉式线程安全&双检锁）：

/**
 * lazy loading
 * 懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 * 可以通过synchronized解决，但也带来效率下降
 * 这是目前好的解决方法之一
 */
public class Mgr06 {
    private static volatile Mgr06 INSTANCE; //JIT

    private Mgr06() {
    }

    public static Mgr06 getInstance() {
        if (INSTANCE == null) {
            //双重检查
            synchronized (Mgr06.class) {
				//拿到锁之后如果还为空那就不执行了，为空执行不下去了
                if(INSTANCE == null) {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new Mgr06();
                }
            }
        }
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr06.getInstance().hashCode());
            }).start();
        }
    }
}

第四种方式（静态内部类）：

/**
 * 静态内部类方式(JVM帮我们保证线程安全)
 * JVM保证单例
 * 加载外部类时不会加载内部类，这样可以实现懒加载
 */
public class Mgr07 {

    private Mgr07() {
    }

    private static class Mgr07Holder {
        private final static Mgr07 INSTANCE = new Mgr07();
    }

    public static Mgr07 getInstance() {
        return Mgr07Holder.INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr07.getInstance().hashCode());
            }).start();
        }
    }
}

第五种方式（枚举）：

/**
 * 枚举单例（完美的单例模式）
 * 不用担心线程安全问题
 * 不仅可以解决线程同步，还可以防止反序列化。
 */
public enum Mgr08 {
	//唯一的取值，下面的调用只能调用这一个，没有争议
    INSTANCE;

	//剩下的都是业务方法
    public void m() {}

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr08.INSTANCE.hashCode());
            }).start();
        }
    }
}