java设计模式--单例模式

什么是设计模式

设计模式是解决问题的方案，学习现有的设计模式可以做到经验复用。
拥有设计模式词汇，在沟通时就能用更少的词汇来讨论，并且不需要了解底层细节。

单例模式-------------------创建型

单例模式的特点

1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。
单例模式保证了全局对象的唯一性，比如系统启动读取配置文件就需要单例保证配置的一致性。

线程安全问题

在使用单例对象的时候，要注意单例对象内的实例变量是会被多线程共享的，推荐使用无状态的对象，不会因为多个线程的交替调度而破坏自身状态导致线程安全问题，比如我们常用的VO，DTO等（局部变量是在用户栈中的，而且用户栈本身就是线程私有的内存区域，所以不存在线程安全问题）。

单例(Singleton)

Intent

确保一个类只有一个实例 并提供该实例的全局访问节点

Class Diagram

使用一个私有的构造函数 一个私有的静态变量以及一个共有的静态函数来实现
私有的构造函数保证了不能通过构造函数来创建实例化 只能通过公有静态函数返回唯一的私有静态变量

单例模式实现两种的方式

1.饿汉式单例(立即加载方式)`

public class Singleton {
    //私有构造方法
	private Singleton() {};
	private static Singleton single = new Singleton();
	
	//静态工厂方法
	public static Singleton getInstance() {
		return single;
	}
}

饿汉式单例在类加载初始化时就创建好一个静态的对象供外部使用，除非系统重启，这个对象不会改变，所以本身就是线程安全的。
Singleton通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问。（事实上，通过Java反射机制是能够实例化构造方法为private的类的，那基本上会使所有的Java单例实现失效。此问题在此处不做讨论，姑且闭着眼就认为反射机制不存在。）

2.懒汉式单例(延迟性加载)

public class Singleton2 {
    //私有构造方法
	private Singleton2() {};
	
	private static Singleton2 single = null;
	
	public static Singleton2 getInstance() {
		if(single == null) {
			single = new Singleton2();
		}
		return single;
	}
}
在这里插入代码片

该示例虽然用延迟加载方式实现了懒汉式单例，但在多线程环境下会产生多个single对象，如何改造请看以下方式:
使用synchronized同步锁

   //私有构造方法
	private Singleton3() {};
	
	private static Singleton3 single = null;
	
	public static Singleton3 getInstance() {
		//等同于 synchronized public static Singleton3 getInstance()
		synchronized(Singleton3.class) {
			//注意:里面的判断一定要加上  否则会出现线程安全问题
			if(single == null) {
				single = new Singleton3();
			}
		}
		return single;
	}
}

在方法上加synchronized同步锁或是用同步代码块对类加同步锁，此种方式虽然解决了多个实例对象问题，但是该方式运行效率却很低下，下一个线程想要获取对象，就必须等待上一个线程释放锁之后，才可以继续运行。**

   //私有构造方法
	private Singleton4() {};
	
	private static Singleton4 single = null;
	
	public static Singleton4 getInstance() {
		if(single == null) {
			synchronized(Singleton4.class) {
				if(single == null) {
					single = new Singleton4();
				}
			}
		}
		return single;
	}
}

使用双重检查进一步做了优化，可以避免整个方法被锁，只对需要锁的代码部分加锁，可以提高执行效率。

静态内部类的实现

    //私有构造方法
	private Singleton5() {};
	
	//静态内部类
	private static class InnerObject{
		private static Singleton5 single = new Singleton5();
	}
	
	public static Singleton5 getInstance() {
		return InnerObject.single;
	}
}

静态内部类虽然保证了单例在多线程并发下的线程安全性，但是在遇到序列化对象时，默认的方式运行得到的结果就是多例的。这种情况不多做说明了，使用时请注意。

静态代码块的实现

    //私有构造方法
	private Singleton6() {};
	
	private static Singleton6 single = null;
	
	//静态代码块
	static {
		single = new Singleton6();
	}
	
	public Singleton6 getInstance() {
		return single;
	}
}

内部枚举实现

   //内部枚举类
	private enum EnumSingleton{
		Singleton;
		private Singleton7 singleton;
		 
        //枚举类的构造方法在类加载是被实例化 
        private EnumSingleton(){
            singleton = new Singleton7();
        }
        public Singleton7 getInstance(){
            return singleton;
        }
    }
    public static Singleton7 getInstance() {
        return EnumSingleton.Singleton.getInstance();
    }
	
}
class Singleton7{
	public Singleton7() {};
}

以上就是对单例模式的部分理解 希望有问题大家可以探讨探讨 哈哈哈