单例模式

什么是单例模式

比如一个团队多个开发者都需要操作日志文件，如果每个人都实例化一个日志对象，会导致不必要的开销。为了解决这类问题，单例模式产生了。单例模式保证一个类仅有一个实例，并提供一个访问它的全局访问点。Windows系统中的回收站就是典型的一种单例模式应用，多次打开回收站不会创建新的窗口。

单例模式的优缺点

优点：

节省内存空间。
避免了频繁的创建销毁对象，可以提高性能。
避免对共享资源的多重占用，简化访问。
为整个系统提供一个全局访问点。

缺点：

不适于变化频繁的独享。
为了节省资源将数据连接池对象设计为单例类，可能会导致共享连接池对象太多，出现连接池溢出。
如果实例化的对象长时间不被使用，系统会认为该对象是垃圾而被回收，这可能会导致对象状态的丢失。

单例模式的实现

1、饿汉式：类加载到内存后，就实例化一个单例，JVM保证线程安全

package SingletonPattern;

public class Singleton01 {
    private static final Singleton01 INSTANCE = new Singleton01();

    private Singleton01(){};

    public static Singleton01 getInstance(){return INSTANCE;}

    public void method(){
        System.out.println("Happy Everyday");
    }

    public static void main(String[] args) {
        Singleton01 m1 = Singleton01.getInstance();
        Singleton01 m2 = Singleton01.getInstance();
        System.out.println(m1 == m2);
    }
}

2、懒汉式：不在类加载的时候初始化，按需初始化

package SingletonPattern;

import org.omg.PortableServer.THREAD_POLICY_ID;

public class Singleton02 {
    //不能定义为final型，因为常量需要初始化
    private static Singleton02 INSTANCE;

    private Singleton02(){

    }

    public static Singleton02 getInstance(){
        if(INSTANCE == null){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Singleton02();
        }
        return INSTANCE;
    }

    public void method(){
        System.out.println("Happy Everyday");
    }

    public static void main(String[] args) {
        for(int i = 0; i < 10; i++){
//同一类的不同对象hashcode是不同的
            new Thread(()->{
                System.out.println(Singleton02.getInstance().hashCode());
            }).start();
        }
    }
}

结果

当多线程操作时，懒汉模式会出现，线程不安全的问题，比如A,B两个线程同时首次创建单例对象，A线程进入判空条件，创建对象之前，B线程此时INSTANCE依然为空，此时A,B线程会创建两个对象。

3、在懒汉式上添加同步方法：解决懒汉模式线程不安全的问题

package SingletonPattern;

import org.omg.PortableServer.THREAD_POLICY_ID;

public class Singleton03 {
    //不能定义为final型，因为常量需要初始化
    private static Singleton03 INSTANCE;

    private Singleton03(){

    }

    public static synchronized Singleton03 getInstance(){
        if(INSTANCE == null){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Singleton03();
        }
        return INSTANCE;
    }

    public void method(){
        System.out.println("Happy Everyday");
    }

    public static void main(String[] args) {
        for(int i = 0; i < 10; i++){
            new Thread(()->{
                System.out.println(Singleton03.getInstance().hashCode());
            }).start();
        }
    }
}

结果

4、双重检查法：虽然通过synchronized解决了线程不安全的问题，但是也带了效率的下降。在同步块中添加判空条件，否则A,B线程拿到锁后都会创建一个对象。

package SingletonPattern;

import org.omg.PortableServer.THREAD_POLICY_ID;

public class Singleton04 {
    //不能定义为final型，因为常量需要初始化
    private static volatile Singleton04 INSTANCE;

    private Singleton04(){

    }

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

    public void method(){
        System.out.println("Happy Everyday");
    }

    public static void main(String[] args) {
        for(int i = 0; i < 10; i++){
            new Thread(()->{
                System.out.println(Singleton04.getInstance().hashCode());
            }).start();
        }
    }
}

5、静态内部类方式：静态内部类在类加载的时候不会加载，在调用getInstance时加载，实现了懒加载。

package SingletonPattern;

import sun.applet.AppletResourceLoader;

/**
 * 静态内部类方式
 */
public class Singleton05 {
    private Singleton05(){};

    private static class Singleton05Holder{
        private final static Singleton05 INSTANCE = new Singleton05();
    }

    public static Singleton05 getInstance(){
        return Singleton05Holder.INSTANCE;
    }

    public void method(){
        System.out.println("Happy Everyday");
    }

    public static void main(String[] args) {
        for(int i = 0; i < 10; i++){
            new Thread(()->{
                System.out.println(Singleton05.getInstance().hashCode());
            }).start();
        }
    }
}

6、枚举实现：枚举类是一个抽象类，没有构造方法，只能有一个实例，不仅可以解决线程同步，还可以防止反序列化。

package SingletonPattern;

public enum Singleton06 {
    INSTANCE;

    public void method(){
        System.out.println("Happy Everyday");
    }

    public static void main(String[] args) {
        for(int i = 0; i < 10; i++){
            new Thread(()->{
                System.out.println(Singleton05.getInstance().hashCode());
            }).start();
        }
    }
}