天天设计模式First——单例模式

本文链接：https://blog.csdn.net/qq_43073128/article/details/107771813

单例模式

单例模式简介

类的单例设计模式，就是采取一定的方法保证在整个软件系统当中，对某个只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法）。

比如说Mybatis当中的SqlSessionFactory，他是当数据存储源的代理，并负责创建SqlSession对象。一般情况下，一个项目只需要一个SqlSessionFactory，这就涉及到单例模式。

单例设计模式的八种方式

饿汉式（静态常量）

实现步骤
1、构造器私有化
2、类的内部创建对象
3、向外暴露一个静态的公共方法。（getInstance）

代码实现

public class Singleton01 {

	private Singleton01 () {}
	
	private static Singleton01 instance = new Singleton01();
	
	public static Singleton01 getInstance() {
		return instance;
	}	
}

优缺点分析
1、优点：写法简单，在类的装载的时候就完成实例化。避免了线程同步问题。
2、缺点：在类装载的时候完成实例化，没有达到Lazy Loading的效果。如果在程序的运行当中从来没使用过这个实例，则会造成内存的浪费。
3、这种方式基于ClassLoader机制，避免了多线程的同步问题，但是，instance在类装载时就进行实例化，在单例模式当中大多数都是调用getInstance方法，但是导致类装载的原因有多种，所以我们不能确定是否有其他的方式（或者是其他的静态方法）导致类的加载，这时候初始化instance就没有达到lazy loading的效果。
4、总结：使用这种单例模式，会避免线程同步的问题，但是可能会造成内存浪费。

饿汉式（静态代码块）

代码实现

public class Singleton02 {
	private Singleton02 () {}

	private static Singleton02 instance;

	static {
		instance = new Singleton02();
	}
	
	private static Singleton02 gteInstance() {
		return instance;
	
	}
}

优缺点分析
1、和刚才的方式相似，就是把类的实例化过程放在静态代码块中，也是在类装载的时候就执行静态代码块中的代码，初始化类的实例。优缺点和上面的一样。
2、结论：使用这种单例模式还是会造成内存浪费。

懒汉式（线程不安全）

代码实现

public class Singleton03 {
	private Singleton03 () {}
	
	private static Singleton03 instance;
	
	public static Singleton03 getInstance() {
		if(instance != null) {
			instance = new Singleton03();
		}
		return instance;
	}
}

优缺点分析
1、起到了lazy loading的效果，但是只能在单线程下使用
2、如果在多线程下，一个线程进入到了if(instance == null)判断语句块，如果此时另外一个线程也通过这个判断语句，这时便会产生了多个实例。两个线程获得的实例是不一样的，所以在多线程环境下不能使用这种获取方式。
3、结论：有线程安全问题，在实际开发当中并不使用这种方式获取实例对象。

懒汉式（线程安全，同步方法）

代码演示

public class Singleton04 {
	private Singleton04 () {}
	
	private static Singleton04 instance;

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

优缺点分析
1、优点：解决了刚才发生的线程不安全的问题
2、缺点：效率低，每个线层在获得类的实例的时候，执行getInstance方法都要进行同步。但是其实这个方法执行一次就行，后面无论是哪一个线程，直接return实例。现在的这个方法需要进行同步，效率太低。
3、结论：在实际开发当中可以使用，但是不提倡，因为效率低

懒汉式（线程安全，同步代码块）

代码实例

public class Singleton05 {
	private Singleton05 () {}
	
	private static Singleton05 instance;

	public static Singleton05 getInstance() {
		if(instance == null) {
			synchronized (Singleton05.class) {
				instance = new Singleton05();
			}
		}
		return instance;
	}
}

优缺点分析
1、这种方式，本来是想做到上面的懒汉式的改进，因为之前的那个同步方法效率太低，所以想改成同步泰马块的方式。
2、但是却并不能起到线程同步的作用。假如说现在有一个线程进入到if(instance == null)的判断当中，此时同时有一个线程也进入到这个判断里面，那么两个线程都可以创建新的实例，所以还是会生成多个实例，不能达到线程同步的作用。
3、结论：因为不能保证线程安全，所以在开发当中不能使用这种方式。

双重检查

代码演示

public class Singleton06 {
	private Singleton06 () {}
	
	private static Singleton06 instance;

	public static Singleton06 getInstance() {
		if(instance == null) {
			synchronized (Singleton06.class) {
				if(instance == null) {
					instance = new Singleton06();				
				}
			}
		}
		return instance;
	}
}

优缺点分析
1、双重检查概念是多线程开发当中经常使用到的，也就是上面的代码示例，进行两次if(instance == null)检查，这样就可以保证线程安全。
2、在这个过程当中，实例代码只用执行一次，后面再次访问的时候，判断if(instance == null)直接实例化对象，也可以避免反复的进行方法同步。
3、线程安全，延迟加载，效率较高
4、结论：这种单例设计模式提倡使用，也是在开发当中推荐使用的。

静态内部类

代码示例

public class Singleton07 {
	private Singleton07 () {}
	
	private static class SingletonInstance {
		private static final Singleton07 INSTANCE = new Singleton07();
	}

	public static Singleton07 getInstance() {
		return SingletonInstance.INSTANCE;
	}
}

优缺点分析
1、这种方式采用了类的装载机制保证初始化实例的时候只有一个线程
2、静态内部类方式在SIngleton07类被装载的时候并不会立即实例化，而是在需要进行实例化的时候才调用getInstance方法，才会开始装载SingletonInstance类，从而实现Singleton07的实例化。
3、类的静态属性只会在第一次加载类的时候初始化，所以在这里JVM帮助我们保证了线程的安全性，这种方式进行类的初始化的时候，别的线程是无法干预的。
4、优点：避免了线程的安全问题，利用静态内部类特点实现延迟加载，效率高
5、结论：在实际的开发当中，推荐使用这种单例模式

枚举

代码演示

public enum Singleton08 {
	INSTANCE;
	
	public void sayHello() {
		System.out.println("hello");
	
	}
	
	public static void main(String[] args) {
		Singleton08 instance = Singleton08.INSTANCE;
		instance.sayHello();
	}
}