设计模式（2.1）单例模式的实现

单例模式的实现

单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。这样的模式有几个好处：

• 1、某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。
• 2、省去了new操作符，降低了系统内存的使用频率，减轻GC压力。
• 单例模式分成两种实现方式：懒汉式、饿汉式

饿汉式和饿汉式

饿汉式： 初始化的时候将单例对象创建出来

public class Student1 {

	// 2：成员变量初始化本身对象
	// 静态类在进行类加载（静态变量初始化）的时候，在JVM内部是保证线程安全的
	private static Student1 student = new Student1();

	// 1.构造私有
	private Student1() {}

	// 3：对外提供公共方法获取对象
	public static Student1 getSingletonInstance() {
		return student;
	}

	public void sayHello(String name) {
		System.out.println("hello," + name);
	}
}

懒汉式：第一次需要的时候再将单例对象创建出来

public class Student2 {

	//1：构造私有
	private Student2(){}
					
	//2：定义私有静态成员变量，先不初始化
	private static Student2 student = null;
					
	//3：定义公开静态方法，获取本身对象
	public static Student2 getSingletonInstance(){
		//没有对象，再去创建
		if (student == null) {
			student = new Student2();
		}
	//有对象就返回已有对象
	return student;
	}					
}

区别：

• 饿汉式是不存在线程安全问题，但是会浪费内存资源
• 懒汉式有点是节省内存资源，但是使用不当，会存在线程安全问题

懒汉式的三种线程安全的写法

• 双重检查锁
• 静态内部类
• 枚举单例

并发编程的三大特性

1、原子性

• 狭义上指的是CPU操作指令必须是原子操作
• 广义上指的是字节码指令是原子操作
• 如何保证原子性呢？加锁（synchronize、Lock）

2、有序性

• 狭义上指的是CPU操作指令是有序执行的
• 广义上指的是字节码指令是有序执行的
• 指令重排序（JIT即时编译器的优化策略）
  • happend-before六大原则
  • 两行代码之间的操作，执行结果不存在影响，就可以发生指令重排序（JMM课程）
  • 示例：

		int i =10;
		boolean a = false;
						
		i ++ ; // 操作1
		a = true; // 操作2

3、可见性

• 在多核（CPU）时代，内存的可见性是一个很常见的并发问题。
• 可见性的解决需要使用到volatile关键字

对象在JVM中的创建步骤

• Student student = new Student();

  • 1.new：开辟JVM堆中的内存空间
  • 2.将内存空间初始化（指的就是对象的成员变量初始化为0值）
  • 3.将内存空间地址（引用地址）赋值给引用类型的变量

• 结论：
  在new对象的时候，JIT即时编译器会根据运行情况，对对象创建的过程进行指令重排序（132）

线程执行代码的时候需要通过竞争CPU时间片去执行

• volatile关键字
  • 作用一：禁止被它修饰的变量发生指令重排操作。是通过内存屏障去完成的禁止指令重排序。
  • 作用二：简单理解是禁止CPU缓存使用，其实是被volatile关键字修饰的变量，在修改之前，都需要将最新CPU缓存中的数据刷新到主内存中。图示：

双重检查锁

public class Student5 {
	//防止指令重排序和保证竞争CPU时间片，保证有序性和可见性
	private volatile static Student5 student;

	private Student5() {
	}

	public static Student5 getSingletonInstance() {
		if (student == null) {
			// B线程检测到student不为空
			synchronized (Student5.class) {
				if (student == null) {
					student = new Student5();
					// A线程被指令重排了，刚好先赋值了；但还没执行完构造函数。
				}
			}
		}
		return student;// 后面B线程执行时将引发：对象尚未初始化错误。
	}
}

静态内部类的单例写法

public class StaticSingleton {

	private StaticSingleton() {}    
	/*
	 * 此处使用一个内部类来维护单例 JVM在类加载的时候，是互斥的，所以可以由此保证线程安全问题
	 */
	private static class SingletonFactory {
		private static StaticSingleton student = new StaticSingleton();
	}
	/* 获取实例 */
	public static StaticSingleton getSingletonInstance() {
		return SingletonFactory.student;
	}
}

class Test{
	public static void main (String[] args) {
		StaticSingleton student = StaticSingleton.getSingletonInstance();
		System.out.println(student);
	}
}

如何破坏一个单例？（导致单例对象不单例）

• 反射攻击

public class SingletonAttack {
	public static void main(String[] args) throws Exception {
		reflectionAttack();
	}

	public static void reflectionAttack() throws Exception {
		//通过反射，获取单例类的私有构造器
		Constructor constructor = DoubleCheckLockSingleton.class.getDeclaredConstructor();
		//设置私有成员的暴力破解
		constructor.setAccessible(true);
		// 通过反射去创建单例类的多个不同的实例
		DoubleCheckLockSingleton s1 = (DoubleCheckLockSingleton)constructor.newInstance();
		// 通过反射去创建单例类的多个不同的实例
		DoubleCheckLockSingleton s2 = (DoubleCheckLockSingleton)constructor.newInstance();
		s1.tellEveryone();
		s2.tellEveryone();
		System.out.println(s1 == s2);
	}
}

• 序列化攻击

public class SingletonAttack {
	public static void main(String[] args) throws Exception {
		serializationAttack();
	}

	public static void serializationAttack() throws Exception {
		// 对象序列化流去对对象进行操作
		ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("serFile"));
		//通过单例代码获取一个对象
		DoubleCheckLockSingleton s1 = DoubleCheckLockSingleton.getInstance();
		//将单例对象，通过序列化流，序列化到文件中
		outputStream.writeObject(s1);
					
		// 通过序列化流，将文件中序列化的对象信息读取到内存中
		ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(new File("serFile")));
		//通过序列化流，去创建对象
		DoubleCheckLockSingleton s2 = (DoubleCheckLockSingleton)inputStream.readObject();
		s1.tellEveryone();
		s2.tellEveryone();
					
		System.out.println(s1 == s2);
	}
}

枚举单例写法（最简单最安全）

public enum EnumSingleton { 
	/*本质就是一个抽象类，没有默认的无参的构造器，
	*导致反射攻击无效。序列化攻击也是由JVM实现防御的。
	*/
	INSTANCE;  //单例对象（实例），底层是由JVM实现的

	public void tellEveryone() {
		System.out.println("This is an EnumSingleton " + this.hashCode());
	}
}