本篇内容介绍了“Java中的单例模式实例分析”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！
1、定义
单例模式(Singleton Pattern)是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。
隐藏其所有的构造方法。
属于创建型模式。
2、适用场景
确保任何情况下都绝对只有一个实例。
3、常见写法
第一种：饿汉式单例：在单例类首次加载时就创建实例
public class HungrySingleton { private static final HungrySingleton INSTANCE = new HungrySingleton(); private HungrySingleton() { } public static HungrySingleton getInstance() { return INSTANCE; }}饿汉式单例静态代码块写法：
public class HungryStaticSingleton { private static final HungryStaticSingleton INSTANCE; static { INSTANCE = new HungryStaticSingleton(); } private HungryStaticSingleton() { } public static HungryStaticSingleton 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 LazyInnerClazzSingleton implements Serializable { private LazyInnerClazzSingleton() { } public static final LazyInnerClazzSingleton getInstance() { return LazyHolder.INSTANCE; } private static class LazyHolder { private static final LazyInnerClazzSingleton INSTANCE = new LazyInnerClazzSingleton(); }}第三种：注册式单例：将每一个实例都缓存到统一的容器中，使用唯一标识获取实例
注册式单例枚举写法：
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; }}Spring中常见的注册式单例写法：
public class ContainerSingleton { private static Map<String, Object> container = new ConcurrentHashMap<>(); private ContainerSingleton() { } public static Object getBean(String clazzName) { // 加synchronized代码块保证线程安全 synchronized (container) { if (!container.containsKey(clazzName)) { Object object = null; try { object = Class.forName(clazzName).newInstance(); container.put(clazzName, object); } catch (Exception e) { e.printStackTrace(); } return object; } return container.get(clazzName); } }}第四种：ThreadLocal线程单例：保证线程内部的全局唯一，且天生线程安全
public class ThreadLocalSingleton { public static final ThreadLocal<ThreadLocalSingleton> THREAD_LOCAL = new ThreadLocal<ThreadLocalSingleton>() { @Override protected ThreadLocalSingleton initialValue() { return new ThreadLocalSingleton(); } }; private ThreadLocalSingleton() { } public static ThreadLocalSingleton getInstance() { return THREAD_LOCAL.get(); }}4、如何防止单例被破坏
1.多线程破坏单例以及解决方法
以懒汉式单例LazySingleton为例：
首先写一个线程实现类，如下：
import com.hzg.study.design.pattern.singleton.lazy.LazySingleton;public class ExecutorThread implements Runnable { @Override public void run() { LazySingleton instance = LazySingleton.getInstance(); System.out.println(Thread.currentThread().getName() + ":" + instance); }}main方法测试：
public class LazySingletonTest { public static void main(String[] args) { Thread thread1 = new Thread(new ExecutorThread()); thread1.start(); Thread thread2 = new Thread(new ExecutorThread()); thread2.start(); System.out.println("----------------------------------------"); }}测试结果：显然出现了两个不同的实例
解决方法1：加synchronized关键字修饰getInstance方法
public class LazySingleton { private static LazySingleton INSTANCE = null; private LazySingleton() { } public static synchronized LazySingleton getInstance() { if (INSTANCE == null) { INSTANCE = new LazySingleton(); } return INSTANCE; }}解决方法2：双重检查锁DoubleCheck
public class LazyDoubleCheckSingleton { private volatile static LazyDoubleCheckSingleton INSTANCE = null; private LazyDoubleCheckSingleton() { } public static LazyDoubleCheckSingleton getInstance() { if (INSTANCE == null) { synchronized (LazyDoubleCheckSingleton.class) { if (INSTANCE == null) { INSTANCE = new LazyDoubleCheckSingleton(); } } } return INSTANCE; }}2.反射破坏单例以及解决方法
以懒汉式单例静态匿名内部类写法LazyInnerClazzSingleton为例：
main方法测试：
public class LazyInnerClazzSingletonTest { public static void main(String[] args) { try { Class<LazyInnerClazzSingleton> aClazz = LazyInnerClazzSingleton.class; Constructor<LazyInnerClazzSingleton> declaredConstructor = aClazz.getDeclaredConstructor(null); declaredConstructor.setAccessible(true); LazyInnerClazzSingleton instance1 = declaredConstructor.newInstance(); LazyInnerClazzSingleton instance2 = LazyInnerClazzSingleton.getInstance(); System.out.println(instance1); System.out.println(instance2); System.out.println(instance1 == instance2); } catch (Exception e) { e.printStackTrace(); } }}测试结果：构建了两个不同的实例
解决方法：在构造器中增加如下if判断
public class LazyInnerClazzSingleton implements Serializable { private LazyInnerClazzSingleton() { if (null != LazyHolder.INSTANCE) { throw new RuntimeException("不允许构建多个实例"); } } public static final LazyInnerClazzSingleton getInstance() { return LazyHolder.INSTANCE; } private static class LazyHolder { private static final LazyInnerClazzSingleton INSTANCE = new LazyInnerClazzSingleton(); }}再次测试：
3.序列化破坏单例以及解决方法
以懒汉式单例静态匿名内部类写法LazyInnerClazzSingleton为例：注意必须先实现序列化接口Serializable
main方法测试：
public static void main(String[] args) { LazyInnerClazzSingleton instance1 = LazyInnerClazzSingleton.getInstance(); LazyInnerClazzSingleton instance2 = null; try ( FileOutputStream fileOutputStream = new FileOutputStream("LazyInnerClazzSingleton.obj"); ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream); FileInputStream fileInputStream = new FileInputStream("LazyInnerClazzSingleton.obj"); ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream); ) { // 序列化 objectOutputStream.writeObject(instance1); objectOutputStream.flush(); // 反序列化 instance2 = (LazyInnerClazzSingleton) objectInputStream.readObject(); System.out.println(instance1); System.out.println(instance2); System.out.println(instance1 == instance2); } catch (Exception e) { e.printStackTrace(); } }测试结果：构建了两个不同的实例
解决方法：新增readResolve方法
public class LazyInnerClazzSingleton implements Serializable { private LazyInnerClazzSingleton() { if (null != LazyHolder.INSTANCE) { throw new RuntimeException("不允许构建多个实例"); } } public static final LazyInnerClazzSingleton getInstance() { return LazyHolder.INSTANCE; } private static class LazyHolder { private static final LazyInnerClazzSingleton INSTANCE = new LazyInnerClazzSingleton(); } private Object readResolve() { return LazyHolder.INSTANCE; }}5、优缺点
优点：
在内存中只有一个实例，减少了内存开销。
可以避免对资源的多重占用。
设置全局访问点，严格控制访问。
缺点：
没有接口，扩展困难。
如果要扩展单例对象，只有修改代码，没有其他途径。
不符合开闭原则
“Java中的单例模式实例分析”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注编程网网站，小编将为大家输出更多高质量的实用文章！
