1、概述
核心作用：
保证一个类只有一个实例，并且提供一个访问该实例的全局访问点
常见场景：
- Window的任务管理器
- Window的回收站
- 项目中，读取配置文件的类，一般也只有一个对象，没必要每次都去new对象读取
- 网站的计数器一般也会采用单例模式，可以保证同步
- 数据库连接池的设计一般也是单例模式
- 在Servlet编程中，每个Servlet也是单例的
- 在Spring中，每个Bean默认就是单例的
- …
优点：
- 由于单例模式只生成一个实例，减少了系统性能开销
- 单例模式可以在系统设置全局访问点，优化共享资源访问
常见的五种单例模式实现方式：
- 饿汉式（线程安全，调用效率高，不能延时加载）
- 懒汉式（线程安全，调用效率不高，可以延时加载）
- DCL懒汉式（由于JVM底层内部模型原因，偶尔会出现问题，不建议使用）
- 饿汉式改进、静态内部类式（线程安全，调用效率高，可以延时加载）
- 枚举单例（线程安全，调用效率高，不能延时加载）
2、饿汉式
饿汉式代码：
package pers.mobian.singleton;
//饿汉式单例
public class SingletonTest01 {
//1.私有化构造器
private SingletonTest01() {
}
//2.类初始化的时候，立即加载该类的对象
private static SingletonTest01 instance = new SingletonTest01();
//3.提供获取该对象的方法，此处没有synchronized，效率高
public static SingletonTest01 getInstance() {
return instance;
}
}
class Test {
public static void main(String[] args) {
SingletonTest01 instance1 = SingletonTest01.getInstance();
SingletonTest01 instance2 = SingletonTest01.getInstance();
System.out.println(instance1 == instance2);
}
}
测试结果：
true
总结：
此种单例模式十分简单，但是如果在SingletonTest01类中，存在初始化的数据，每次仅仅初始化类，并未真真调用该类时，就会出现占用空间的现象。代码如下：
public class SingletonTest01 {
byte[] a1 = new byte[1024];
byte[] a2 = new byte[1024];
byte[] a3 = new byte[1024];
private SingletonTest01() {
}
private static SingletonTest01 instance = new SingletonTest01();
public static SingletonTest01 getInstance() {
return instance;
}
}
于是出现了懒汉式单例模式。
3、懒汉式
懒汉式代码：
package pers.mobian.singleton;
public class SingletonTest02 {
byte[] a1 = new byte[1024];
byte[] a2 = new byte[1024];
byte[] a3 = new byte[1024];
//1.私有化构造器
private SingletonTest02() {
}
//2.类初始化的时候，立即加载该类的对象
private static SingletonTest02 instance;
//3.提供获取该对象的方法，此处有synchronized，效率较低
public static synchronized SingletonTest02 getInstance() {
if (instance == null) {
instance = new SingletonTest02();
}
return instance;
}
}
class Test1 {
public static void main(String[] args) {
SingletonTest02 instance1 = SingletonTest02.getInstance();
SingletonTest02 instance2 = SingletonTest02.getInstance();
System.out.println(instance1 == instance2);
}
}
测试结果：
true
总结：
此方法可以延时加载，仅仅调用该方法后，才会初始方法区中的数据，继而避免出现饿汉式单例模式的问题。但是使用了synchronized关键字，在达到了线程安全的同时会出现效率低下的问题，继而引入了DCL（双重检测锁）懒汉式。
4、DCL（Double Check Lock）懒汉式
DCL懒汉式代码：
package pers.mobian.singleton;
public class SingletonTest03 {
//1.私有化构造器
private SingletonTest03() {
}
//2.类初始化的时候，立即加载该类的对象
//此处还需要加上volatile关键字：此关键字直接指向内存，防止在运行第三步的时候，出现多个线程运行到synchronized代码块后，if判断语句之前
private volatile static SingletonTest03 instance;
//因为此操作不是原子性操作，所以在内存中会出现这样三步的操作
/*
* 1.分配内存
* 2.执行构造方法
* 3.指向地址
* */
//这也就是为什么要使用volatile关键字
//3.提供获取该对象的方法，此处没有synchronized，效率较低
public static SingletonTest03 getInstance() {
//此处为第一重锁，判断对象是否被创建
if (instance == null) {
synchronized (SingletonTest03.class) {
//此为第二重锁，判断自己是否是第一个拿到锁的，继而创建对象
if (instance == null) {
instance = new SingletonTest03();
}
}
}
return instance;
}
}
class Test3 {
public static void main(String[] args) {
SingletonTest03 instance1 = SingletonTest03.getInstance();
SingletonTest03 instance2 = SingletonTest03.getInstance();
System.out.println(instance1 == instance2);
}
}
测试结果：
true
总结：
使用此单例模式，可以避免出现懒汉式单例synchronized关键字将整个方法锁住，继而影响效率。DCL单例中的synchronized关键字只锁了if判断成功以后的代码块，如果instance不是null，则会跳过直接return，不会降低效率。
5、饿汉式改进、静态内部类式
饿汉式改进、静态内部类式代码：
package pers.mobian.singleton;
//静态内部类实现
public class SingletonTest04 {
private SingletonTest04(){}
private static class InnerClass{
private static final SingletonTest04 instance = new SingletonTest04();
}
public static SingletonTest04 getInstance(){
return InnerClass.instance;
}
}
class Test4{
public static void main(String[] args) {
SingletonTest04 instance1 = SingletonTest04.getInstance();
SingletonTest04 instance2 = SingletonTest04.getInstance();
System.out.println(instance1 == instance2);
}
}
测试结果：
true
总结：
采用此方法，可以延时加载，并且线程安全。但是java中存在反射机制，能够改变内部的private关键字，于是引入了枚举单例模式
反射破坏单例模式测试代码：
package pers.mobian.singleton;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
//静态内部类实现
public class SingletonTest04 {
private SingletonTest04(){}
private static class InnerClass{
private static final SingletonTest04 instance = new SingletonTest04();
}
public static SingletonTest04 getInstance(){
return InnerClass.instance;
}
}
class Test4{
public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {
//利用反射获取其对应的构造器方法
Constructor<SingletonTest04> declaredConstructor = SingletonTest04.class.getDeclaredConstructor(null);
//开启访问权限
declaredConstructor.setAccessible(true);
//直接调用方法，进行实例化输出
SingletonTest04 instance1 = SingletonTest04.getInstance();
SingletonTest04 instance2 = declaredConstructor.newInstance();
System.out.println(instance1 == instance2);
System.out.println(instance1.hashCode());
System.out.println(instance2.hashCode());
}
}
执行结果：
false
2137211482
920011586
6、枚举单例
newInstance类源码：
public T newInstance(Object ... initargs)
throws InstantiationException, IllegalAccessException,
IllegalArgumentException, InvocationTargetException
{
if (!override) {
Class<?> caller = Reflection.getCallerClass();
checkAccess(caller, clazz, clazz, modifiers);
}
if ((clazz.getModifiers() & Modifier.ENUM) != 0)
//此行代码表示，不能反射枚举类型的对象
throw new IllegalArgumentException("Cannot reflectively create enum objects");
ConstructorAccessor ca = constructorAccessor; // read volatile
if (ca == null) {
ca = acquireConstructorAccessor();
}
@SuppressWarnings("unchecked")
T inst = (T) ca.newInstance(initargs);
return inst;
}
枚举单例测试代码：
package pers.mobian.singleton;
public enum SingletonTest05 {
INSTANCE;
public SingletonTest05 getInstance(){
return INSTANCE;
}
}
class test05{
public static void main(String[] args) {
SingletonTest05 instance1 = SingletonTest05.INSTANCE;
SingletonTest05 instance2 = SingletonTest05.INSTANCE;
System.out.println(instance1==instance2);
}
}
测试结果：
true
总结：
利用枚举的方式创建单例模式，可以避免反射对其内部进行关键字的破坏，继而导致单例模式失效。它的缺点也是不能延时加载
7、总结
不同的单例模式拥有不同的运用场景，灵活运用。将单例模式的思想带入到我们的编码中，才是学习设计模式的关键。
标签：getInstance,模式,SingletonTest04,instance,static,单例,public From： https://blog.51cto.com/u_15942107/6017180