Java高级之单例的合理用法

---

                                       本文来自刘兆贤_CSDN博客 ，引用必须注明出处！

单例，目的是共用一份“类”的引用，去操作其内部业务；故单例，应该用于多线程。

如果是单线程，建议直接使用“类”作成员变量，来操作其内部业务。

优势：不需要多次初始化“类”对象，共用一份“类”的引用。

劣势：使用完毕，需要将“单例/其内部成员变量”置空；因为它是静态的，所以默认情况下，其内部成员变量不会被GC回收。

常见写法有三种：

饿汉式

public static class HungrySingleInstance {
		private static final HungrySingleInstance instance = new HungrySingleInstance();

		private HungrySingleInstance() {
		}

		public static HungrySingleInstance getInstance() {
			return instance;
		}
	}

类调用getInstance方法时，才执行初始化操作。

静态式

	public static class HolderSingleInstance {

		private HolderSingleInstance() {
		}

		private static class SingleHolder {
			private static final HolderSingleInstance instance = new HolderSingleInstance();
		}

		public static HolderSingleInstance getInstance() {
			return SingleHolder.instance;
		}
	}

跟上面类似，区别是上面类如果调用其他方法，也会初始化instance，有“提前占内存，但不使用”的嫌疑！而下面这个类，则完全没有，只有调用getInstance方法，才获取单例对象。

懒汉式

	public static class LazySingleInstance {
		private static volatile LazySingleInstance instance;

		private LazySingleInstance() {
		}

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

在getInstance执行时，才去初始化；加锁，是为了保证两条线程，同时进入时，只初始化一次，且都拿到初始化后的对象。

在方法内加锁，是为了保证多个线程，在方法内部等待，而非在方法区句柄处等待，效率更高一些。volatile在此处，仅从虚拟机层次，保证实例可见性，以便不会被二次生成。

问题1：静态变量不销毁，就一直持有其内部成员变量，容易造成页面级别的内存泄露。

问题2、单例内的非静态成员变量，可以使用弱引用封装，或者用完置空，来保证回收；而静态变量，即使加弱引用，也不会被主动GC回收，因为它仍然是静态变量。

了解更多内存知识，可移步：Java高级之内存初始化时机