Java设计模式之单例模式的学习

本篇是本人的第二篇博客
旨在记录本人对于Java设计模式之单例模式的学习和理解，也希望本篇可以对一些正在学习的小伙伴起到一些帮助
单例模式(singleton)的特点：
1、单例模式有且仅有一个实例；
2、单例类必须为自己创建一个实例对象；
3、单例类必须为其他类提供自己的实例对象。
一句话概括就是单例模式确保一个类只有一个实例对象，并向整个系统提供这个实例。
单例模式常见的实现方式：
饿汉式

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

    private Mgr01(){};

    public static Mgr01 getInstance(){return INSTANCE;}

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

代码执行结果：

true

类加载到内存后，就实例化一个单例，JVM保证线程安全，这是最常用也最推荐的一种实现方式
缺点是：不论这个类是不是需要用到，他在JVM对Class进行装载的时候就会实例化一个对象出来

饿汉式的另一种写法

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

    private Mgr02(){};

    public static Mgr02 getInstance(){return INSTANCE;}

}

这里其实和Mgr01是一样的写法，只是将类的实例化放到了静态代码块中

懒汉式

public class Mgr03 {
    private static Mgr03 INSTANCE;
    
    private Mgr03(){ }
    
    public static Mgr03 getInstance(){
        if(INSTANCE == null){
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Mgr03();
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for (int i = 0;i < 10;i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Mgr03.getInstance().hashCode());
                }
            }).start();
        }
    }
}

代码执行结果：

2138956606
1907303951
912695856
402421002
683606489
2088305711
1681987865
397829811
1185063871
695977737

这里是打印的Mgr03的hashcode()的值，很明显，他们并不是同一个对象
这种写法的懒汉式，虽然达到了在使用时才会初始化实例对象的目的，但是在多线程的情况下，并不能保证线程的安全性

通过加锁来保证懒汉式的安全性

public class Mgr04 {
    private static Mgr04 INSTANCE;

    private Mgr04(){ }

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

    public static void main(String[] args) {
        for (int i = 0;i < 10;i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Mgr04.getInstance().hashCode());
                }
            }).start();
        }
    }
}

执行结果：

1138243632
1138243632
1138243632
1138243632
1138243632
1138243632
1138243632
1138243632
1138243632
1138243632

这里的synchronized关键字是加在static方法上的，所以是对这个类进行加锁，虽然保证了线程的安全性，但是在执行效率上，难免会有一定的降低

通过同步代码块的方式来提高效率

public class Mgr05 {
    private static Mgr05 INSTANCE;

    private Mgr05(){ }

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

    public static void main(String[] args) {
        for (int i = 0;i < 10;i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Mgr05.getInstance().hashCode());
                }
            }).start();
        }
    }
}

代码执行结果：

1226880356
1226880356
1226880356
1279846056
1279846056
1279846056
1279846056
1732782037
868907500
925932875

这种方式，第一个线程进入的时候，可能在执行到第一次null判断还没有进入加锁的同步代码块的时候，有其他的线程也进行判断，其他的线程先进入到同步代码块中的时候，获取到了锁，然后将下面的实例化的语句执行完了之后，释放了这个锁，然后那些执行看null值判断但是没有实例化的线程，因为对于这些线程来说，他们还是null值状态，所以会继续执行加锁的实例化代码，因此会创建出多个是对象出来。

在同步代码块中进行二次判断

public class Mgr06 {
    private static volatile Mgr06 INSTANCE;

    private Mgr06(){ }

    public static Mgr06 getInstance(){
    	 if(INSTANCE == null){
            synchronized (Mgr06.class){
                //双重检查INSTANCE是否为空
                if (INSTANCE == null) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new Mgr06();
                }
            }
        }
        return INSTANCE;
    }
    public static void main(String[] args) {
        for (int i = 0;i < 10;i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Mgr06.getInstance().hashCode());
                }
            }).start();
        }
    }
}

代码执行结果：

1842520111
1842520111
1842520111
1842520111
1842520111
1842520111
1842520111
1842520111
1842520111
1842520111

这里确实可以保证单例，但是整个代码结构会比较复杂

通过内部类的方式实现懒汉式加载

public class Mgr07 {

    private Mgr07(){}

    private static class Mgr07Holder{
        private final static Mgr07 INSTANCE = new Mgr07();
    }

    public static Mgr07 getInstance(){
        return Mgr07Holder.INSTANCE;
    }

    public static void main(String[] args) {{
        for (int i = 0;i < 100;i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Mgr06.getInstance().hashCode());
                }
            }).start();
        }
    }

    }
}

代码执行结果：

982203456
982203456
982203456
982203456
982203456
982203456
982203456
982203456
982203456
982203456

这里是通过内部类的方式来实现的，外部类在访问Mgr07的getInstance()方法的时候，返回的是其内部类的静态常量，这里与Mgr01一样，是JVM帮我们实现了线程的安全性，而Mgr07在加载的时候，其内部类是不会被加载的，也就是没有被实例化，只有在我们调用getInstance()方法的时候，内部类才会被加载，Mgr07才会被实例化。

大神代码（Java语音的创始人之一James Gosling在《Effective Java》中写出的代码）：

public enum Mgr08 {
    INSTANCE;

    private void m(){}

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

代码执行结果：

1226880356
1226880356
1226880356
1226880356
1226880356
1226880356
1226880356
1226880356
1226880356
1226880356

这里的是通过Java的枚举类来实现的，枚举单例，不经可以保证线程的安全性，还可以防止反序列化。Java规范中规定，每一个枚举类型极其定义的枚举变量在JVM中都是唯一的，因此在枚举类型的序列化和反序列化上，Java做了特殊的规定：在序列化的时候Java仅仅是将枚举对象的name属性输出到结果中，反序列化的时候则是通过 java.lang.Enum 的 valueOf() 方法来根据名字查找枚举对象。所以，以上面的枚举为例，序列号的时候只会将INSTANCE输出，然后再根据INSTANCE这个名称，查找对应的枚举类型，因此，反序列化之后得到的对象也会与序列化之后的实例对象相同。这个实在是要膜拜，不愧是Java之父。