简介
单例模式：是一种常用的软件设计模式，在它的核心结构中值包含一个被称为单例的特殊类。一个类只有一个实例，即一个类只有一个对象实例。
特点
1.单例模式确保程序中一个类最多只有一个实例。
2.单例模式也提供访问这个实例的全局点。
3.在java中实现单例模式需要私有化构造器、一个静态变量和一个静态方法。
4.确定性能和资源上的限制，然后小心的选择适当的方法来实现单例，以解决多线程的问题。
5.如果使用多个类加载器、可能导致单例类失效而产生多个实例。
6.如果使用jvm1.2或之前的版本，你必须建立单例注册表，以免垃圾收集器将单件回收
作用
1.控制资源的使用，通过线程同步来控制资源的并发访问；
2.控制实例产生的数量，达到节约资源的目的。
3.作为通信媒介使用，也就是数据共享，它可以在不建立直接关联的条件下，让多个不相关的两个线程或者进程之间实现通信
基本实现思路
实现主要分为2个步骤
1.私有化自己的构造器，不让外部通过调用构造方法来实例化对象。
2.创建一个静态方法，通过静态方法来返回对应的对象。
注意
在多线程状态下使用单例模式要避免多个线程创建多个对象。
单例模式的八种实现
1.饿汉式(通过静态常量实现)[可用]
public class HungryConstant {
private final static HungryConstant INSTANCE = new HungryConstant();
private HungryConstant() {
}
public static HungryConstant getInstance() {
return INSTANCE;
}
}
优点：写法简单，在类装载的时候实例化，避免了线程同步问题。</br>
缺点：没达到懒加载的效果，如果没使用过这个类就会造成没必要的内存浪费
2.饿汉式(通过静态代码块实现)[可用]
public class HungryCodeBlock {
private static HungryCodeBlock instance;
static {
instance = new HungryCodeBlock();
}
private HungryCodeBlock() {
}
public static HungryCodeBlock getInstance() {
return instance;
}
}
类装载时执行代码块中内容，优缺点同上
3.懒汉式(线程不安全)[不可用]
public class LazyThreadNotSafe {
private static LazyThreadNotSafe instance;
private LazyThreadNotSafe() {
}
public static LazyThreadNotSafe getInstance() {
if (instance == null) {
instance = new LazyThreadNotSafe();
}
return instance;
}
}
如果2个线程同时执行到if语句，A线程还没完全实例化，B线程也通过了判断，就会实例化2个对象。多线程下不推荐使用。
4.懒汉式(线程安全,同步方法)[不推荐用]
public class LazyMethodSync {
private static LazyMethodSync instance;
private LazyMethodSync() {
}
public static synchronized LazyMethodSync getInstance() {
if (instance == null) {
instance = new LazyMethodSync();
}
return instance;
}
}
这边虽然说对多线程进行了处理，但是实际上只要对一次运行这个方法进行实例化时进行同步就行了，其他情况可以直接return，对方法进行同步效率太低。
5.懒汉式(线程同步,同步代码块)[不可用]
public class LazyCodeBlockSync {
private static LazyCodeBlockSync instance;
private LazyCodeBlockSync() {
}
public static LazyCodeBlockSync getInstance() {
if (instance == null) {
synchronized (LazyCodeBlockSync.class) {
instance = new LazyCodeBlockSync();
}
}
return instance;
}
}
这边的情况与第三种类似，如果2个线程都通过if语句，那就意味着会产生多个实例。
6.懒汉式(双重检查)[推荐使用]
public class LazyDoubleCheck {
private static volatile LazyDoubleCheck instance;
private LazyDoubleCheck() {
}
public static LazyDoubleCheck getInstance() {
if (instance == null) {
synchronized (LazyDoubleCheck.class) {
if (instance == null) {
instance = new LazyDoubleCheck();
}
}
}
return instance;
}
}
通过2次if语句来检查，这样就只会实例化一次。</br>
注意这边volatile关键字，为何要加这个关键字呢？</br>
①分配空间给对象
②在空间内创建对象
③将对象赋值给引用sole
正常情况下执行顺序可能是①->②->③，但是这边可能会出现指令重排的情况，将一些不重要的运行过程重新分配执行顺序进行优化，执行顺序可能会有所改变，可能会出现①-> ③-> ②的情况，这是后A线程执行到第二步完成，instance已经有了引用，但是对象还没完全实例化，是个不安全的对象，这时候B线程抢占了cpu，然后B线程执行到if语句到时候发现instance已经不为null然后直接返回一个不安全的对象。volatile关键字在这边就是防止指令的重排序，当然volatile关键字还有其他作用这边就不进行介绍了。
7.静态内部类[推荐使用]
public class InternalClass {
private InternalClass() {
}
private static class InternalClassInstance {
private final static InternalClass INSTANCE = new InternalClass();
}
public static InternalClass getInstance() {
return InternalClassInstance.INSTANCE;
}
public void test() {
System.out.println("This is an internal class singleton");
}
}
这边和饿汉式的实现类型，但是饿汉式没有懒加载的作用，而这边只有当调用getInstance方法时才会进行实例化。
8.枚举[推荐使用]
public enum EnumClass {
INSTANCE;
public void test() {
System.out.println("This is an enum singleton");
}
}
枚举类的方法调用
EnumClass.INSTANCE.test();
枚举都是通过final static修饰的所以其实和饿汉模式类似，保证了线程的安全。
