单例模式：
单例模式(Singleton Pattern)是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。
饿汉式单例：
饿汉式单例模式在类加载的时候就立即初始化，并且创建单例对象。它绝对线程安全，在线程还没出现以前就实例化了，不可能存在访问安全问题。
public class HungrySingleton {
//类加载时初始化
private static final HungrySingleton instance = new HungrySingleton();
private HungrySingleton(){}
//全局访问点
public HungrySingleton getInstance(){
return instance;
}
}
优点:没有加任何锁、执行效率比较高，用户体验比懒汉式单例模式更好。
缺点:类加载的时候就初始化，不管用与不用都占着空间，浪费了内存，有可能“占着茅坑不拉屎”。
懒汉式单例：
懒汉式单例模式是被外部类调用的时候内部类才会加载，它是线程不安全的。
public class LazySingleton {
private static LazySingleton instance = null;
private LazySingleton() {}
public static LazySingleton getInstance() {
//外部类调用的时候内部加载
if (instance == null) {
instance = new LazySingleton();
}
return instance;
}
}
很明显这样子的懒汉式单例是线程不安全的，如何保证其线程安全呢？于是呢，我们给获取实例的方法加上锁
public class LazySingleton {
private static LazySingleton instance = null;
private LazySingleton() {}
public static synchronized LazySingleton getInstance() {
if (instance == null) {
instance = new LazySingleton();
}
return instance;
}
}
synchronized可保证线程安全，但是，用 synchronized 加锁时，在线程数量比较多的情况下，如果CPU分配压力上升，则会导致大批线程阻塞，从而导致程序性能大幅下降。于是我们改进加锁方法：
public class LazySingleton {
private static LazySingleton instance = null;
private LazySingleton() {}
public static LazySingleton getInstance() {
if (instance == null) {
synchronized (LazySingleton.class){
if (instance == null)
instance = new LazySingleton();
}
}
return instance;
}
}
使用双重检查锁，在保证线程安全的情况下，相比于直接加锁提升了性能。但是，使用synchronized总归要降低性能，我们从类初始化的角度下考虑，使用静态内部类。
public class LazySingleton {
private LazySingleton() {}
public static final LazySingleton getInstance() {
return LazyInnerHolder.LAZY;
}
//初始化LazySingleton要先初始化LazyInnerHolder,
private static class LazyInnerHolder{
private static LazySingleton LAZY = new LazySingleton();
}
}
这种方式兼顾了饿汉式单例模式的内存浪费问题和 synchronized 的性能问题。内部类一定是要在方法调用之前初始化，巧妙地避免了线程安全问题。
注册式单例
注册式单例模式又称为登记式单例模式，就是将每一个实例都登记到某一个地方，使用唯一的标识 获取实例。注册式单例模式有两种:一种为枚举式单例模式，另一种为容器式单例模式。
注册式单例可解决反射和序列化导致的破坏单例行为,先埋坑以后再填。
主要是在反射机制和序列化readResolve中解决
枚举式单例
public enum EnumSingleton {
INSTANCE;
private Object data;
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
public static EnumSingleton getInstance() {
return INSTANCE;
}
}
容器式单例
public class ContainerSingleton {
private ContainerSingleton(){}
private static Map<String,Object> ioc = new ConcurrentHashMap<String,Object>();
public static Object getBean(String className){
synchronized (ioc) {
if (!ioc.containsKey(className)) {
Object obj = null;
try {
obj = Class.forName(className).newInstance();
ioc.put(className, obj); } catch (Exception e) {
e.printStackTrace();
}
return obj;
} else {
return ioc.get(className);
}
}
}
}
容器式单例模式适用于实例非常多的情况，便于管理。但它是非线程安全的。 Spring 中的容器式单例模式的实现代码:
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {
/** Cache of unfinished FactoryBean instances: FactoryBean name --> BeanWrapper */
private final Map<String, BeanWrapper> factoryBeanInstanceCache = new ConcurrentHashMap<>(16); ...
}
破坏单例模式
反射机制
其实以上的例子已经很好的说明了单例模式的用法，但是呢，通过Java 的反射机制，我们可以轻易的去调用其构造方法，然后再去调用getInstance(),就会创建出来不同的实例。
public static void main(String[] args) {
Class clazz = LazySingleton.class;
try {
Constructor constructor = clazz.getDeclaredConstructor(null);
constructor.setAccessible(true);
Object o = constructor.newInstance();
Object o2= constructor.newInstance();
System.out.println(o==o2);
} catch (Exception e) {
e.printStackTrace();
}
}
--------------------------------------------------------------------------------------------
false
Process finished with exit code 0
序列化
一个单例对象创建好后，有时候需要将对象序列化然后写入磁盘，下次使用时再从磁盘中读取对象 并进行反序列化，将其转化为内存对象。反序列化后的对象会重新分配内存，即重新创建。如果序列化 的目标对象为单例对象，就违背了单例模式的初衷，相当于破坏了单例。
//反序列化导致破坏单例模式
public class SeriableSingleton implements Serializable {
//序列化就是把内存中的状态通过转换成字节码的形式 //从而转换一个 I/O 流，写入其他地方(可以是磁盘、网络 I/O)
//内存中的状态会永久保存下来 //反序列化就是将已经持久化的字节码内容转换为 I/O 流
//通过 I/O 流的读取，进而将读取的内容转换为 Java 对象 //在转换过程中会重新创建对象 new
public final static SeriableSingleton INSTANCE = new SeriableSingleton(); private SeriableSingleton(){}
public static SeriableSingleton getInstance(){
return INSTANCE;
}
}
反序列化后的对象和手动创建的对象是不一致的，实例化了两次，违背了单 例模式的设计初衷。那么，我们如何保证在序列化的情况下也能够实现单例模式呢?其实很简单，只需 要增加 readResolve()方法即可。(这里需要JDK的ObjectInputStream类的readObject()方法).
public class SeriableSingleton implements Serializable {
//序列化就是把内存中的状态通过转换成字节码的形式 //从而转换一个 I/O 流，写入其他地方(可以是磁盘、网络 I/O)
//内存中的状态会永久保存下来 //反序列化就是将已经持久化的字节码内容转换为 I/O 流
//通过 I/O 流的读取，进而将读取的内容转换为 Java 对象 //在转换过程中会重新创建对象 new
public final static SeriableSingleton INSTANCE = new SeriableSingleton(); private SeriableSingleton(){}
public static SeriableSingleton getInstance(){
return INSTANCE;
}
private Object readResolve(){
return INSTANCE;
}
}
