JUC学习：单例模式

单例模式学习

Java中单例(Singleton)模式是一种广泛使用的设计模式。单例模式的主要作用是保证在Java程序中，某个类只有一个实例存在。一些管理器和控制器常被设计成单例模式。

​ 单例模式有很多好处，

1. 单例模式保证了 系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使
   用单例模式可以提高系统性能
2. 当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用 new
3. 单例模式 使用的场景：需要 频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即：重量级
   对象)，但又经常用到的对象、 工具类对象、频繁访问数据库或文件的对象(比如 数据源、session 工厂等)

总之它能够避免实例对象的重复创建，不仅可以减少每次创建对象的时间开销，还可以节约内存空间；能够避免由于操作多个实例导致的逻辑错误。如果一个对象有可能贯穿整个应用程序，而且起到了全局统一管理控制的作用，那么单例模式也许是一个值得考虑的选择。

下面是实现单例模式的五种写法

饿汉模式

/**
 * 实现饿汉模式
 */
public class Hunger {

    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 byte[] data5=new byte[1024*1024];
    private byte[] data6=new byte[1024*1024];


    private Hunger() {
    }

    private final static Hunger HUNGER = new Hunger();

    //上来就把对象加载出来，如果不去使用它，就会浪费内存
    public static Hunger getInstance() {
        return HUNGER;
    }
}

从代码中我们看到，类的构造函数定义为private的，保证其他类不能实例化此类，然后提供了一个静态实例并返回给调用者。饿汉模式是最简单的一种实现方式，饿汉模式在类加载的时候就对实例进行创建，实例在整个程序周期都存在。它的好处是只在类加载的时候创建一次实例，不会存在多个线程创建多个实例的情况，避免了多线程同步的问题。它的缺点也很明显，即使这个单例没有用到也会被创建，而且在类加载之后就被创建，如果使用这个类，内存就被浪费了。

懒汉式

// 饱汉
// UnThreadSafe
//单线程下确实没问题，但多线程下会出问题
public class Singleton1 {
  private static Singleton1 singleton = null;
  private Singleton1() {
  }
  public static Singleton1 getInstance() {
    if (singleton == null) {
      singleton = new Singleton1();
    }
    return singleton;
  }
}

优点：懒加载启动快，资源占用小，使用时才实例化，无锁。

缺点：非线程安全。

懒汉模式中单例是在需要的时候才去创建的，如果单例已经创建，再次调用获取接口将不会重新创建新的对象，而是直接返回之前创建的对象。如果某个单例使用的次数少，并且创建单例消耗的资源较多，那么就需要实现单例的按需创建，这个时候使用懒汉模式就是一个不错的选择。但是这里的懒汉模式并没有考虑线程安全问题，在多个线程可能会并发调用它的getInstance()方法，导致创建多个实例，因此需要加锁解决线程同步问题，在getInstance（）方法上添加synchronized 关键字

双重检查（重点掌握）

加锁的懒汉模式看起来即解决了线程并发问题，又实现了延迟加载，然而它存在着性能问题，依然不够完美。synchronized修饰的同步方法比一般方法要慢很多，如果多次调用getInstance()，累积的性能损耗就比较大了。因此就有了双重校验锁，先看下它的实现代码

public class DoubleCheck {
    private static volatile DoubleCheck doubleCheck = null;

    private DoubleCheck() {

    }
    public static DoubleCheck getInstance() {
        if (doubleCheck == null) {
            synchronized (DoubleCheck.class) {
                if (doubleCheck == null) {
                    doubleCheck = new DoubleCheck();//这个不是原子性操作
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个对象指向这个内存空间
                     */
                }
            }
        }
        return doubleCheck;
    }
}

doubleCheck= new DoubleCheck(); 这段代码其实是分为三步执行：

1. 为 doubleCheck分配内存空间
2. 初始化 doubleCheck
3. 将 doubleCheck指向分配的内存地址

但是由于 JVM 具有指令重排的特性，执行顺序有可能变成 1->3->2。指令重排在单线程环境下不会出现问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。例如，线程 T1 执行了 1 和 3，此时 T2 调用 getInstance() 后发现 doubleCheck不为空，因此返回 doubleCheck，但此时 doubleCheck还未被初始化。使用 volatile 可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行

静态内部类

public class Singleton {
    /**
     * 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例
     * 没有绑定关系，而且只有被调用到才会装载，从而实现了延迟加载
     */
    private static class SingletonHolder{
        /**
         * 静态初始化器，由JVM来保证线程安全
         */
        private static Singleton instance = new Singleton();
    }
    /**
     * 私有化构造方法
     */
    private Singleton(){
    }
    public static  Singleton getInstance(){
        return SingletonHolder.instance;
    }
}

这种方式同样利用了类加载机制来保证只创建一个instance实例。它与饿汉模式一样，也是利用了类加载机制，因此不存在多线程并发的问题。不一样的是，它是在内部类里面去创建对象实例。这样的话，只要应用中不使用内部类，JVM就不会去加载这个单例类，也就不会创建单例对象，从而实现懒汉式的延迟加载。也就是说这种方式可以同时保证延迟加载和线程安全。

枚举类

public enum Singleton{
    instance;
    public void whateverMethod(){}    
}

对枚举类进行反射获取构造函数的时候，会发现枚举的构造函数并不是空参的，而是一个

有俩参数的（String s，int i）构造器，这个用idea和javap都发现不了，需要放String .class和int.class这俩是确定的，不要放Integer！！

前四种都还是有安全隐患，都可以使用反射进行破解，把私有构造方法变成公用，然后把对象创建出来,只有枚举才能防止，但枚举不常用。

破坏单例模式的三种方式

1. 反射
2. 序列化（不常用）
3. 克隆（不常用，要实现接口）

/**
 * 序列化对单例的破坏
 */
public class SingletonTest09 {
	
	public static void main(String[] args) throws Exception{
		
		System.out.println("-----------序列化----------------------");
	     Singleton originSingleton = Singleton.getInstance();
	     ByteArrayOutputStream bos = new ByteArrayOutputStream();
	     ObjectOutputStream oos = new ObjectOutputStream(bos);
	      oos.writeObject(Singleton.getInstance());
	      ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
	      ObjectInputStream ois = new ObjectInputStream(bis);
	      Singleton serializeSingleton = (Singleton) ois.readObject();
	      System.out.println(originSingleton == serializeSingleton);//false	      
	      System.out.println("-----------反射----------------------");
	      //通过反射获取
	        Constructor<Singleton> cons = Singleton.class.getDeclaredConstructor();
	        cons.setAccessible(true);
	        Singleton reflextSingleton = cons.newInstance();
	        System.out.println(reflextSingleton == originSingleton);//false	        
	        System.out.println("---------------------------克隆----------------------");	   
	        Singleton cloneSingleton = (Singleton) originSingleton.clone();
	        System.out.println(cloneSingleton == originSingleton);//false
	    
	}
	
	private static class Singleton  implements Serializable,Cloneable{
		/**
		 * 1.构造方法私有化，外部不能new
		 */
		private Singleton() {}
				
		//2.本类内部创建对象实例
		private static  volatile  Singleton instance;
				
		//3.提供一个公有的静态方法，返回实例对象
		public static  Singleton getInstance() {
			if(instance == null) {
				synchronized (Singleton.class) {
					if(instance == null) {
						instance = new Singleton();
					}
				}
			}
			return instance;
		}
		@Override
		 protected Object clone() throws CloneNotSupportedException {
		     return super.clone();
		  }		 
	}
	
}
 

解决方案如下：

1、防止反射

定义一个全局变量，当第二次创建的时候抛出异常

2、防止克隆破坏

重写clone(),直接返回单例对象

3、防止序列化破坏

添加readResolve(),返回Object对象

上面提到的四种实现单例的方式都有共同的缺点：

1）需要额外的工作来实现序列化，否则每次反序列化一个序列化的对象时都会创建一个新的实例。

2）可以使用反射强行调用私有构造器（如果要避免这种情况，可以修改构造器，让它在创建第二个实例的时候抛异常）