单例模式singleton

简介

单例模式：是一种常用的软件设计模式，在它的核心结构中值包含一个被称为单例的特殊类。一个类只有一个实例，即一个类只有一个对象实例。

特点

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修饰的所以其实和饿汉模式类似，保证了线程的安全。