设计模式之单例模式的写法

单例模式的写法

全程干货

所有需要注意的点都在代码注释中有写，文章不多赘述。

Mgr1.java

package com.DP.singleton;
/*
单例模式-饿汉式
类加载到内存后，就会实例化一个单例，JVM保证线程安全
简单实用，常见，常用
唯一缺点：无论是否用到，类装载时就完成实例化
编码要点：
    1psv一个类实例，保证单例不可变
    2将类构造函数以private修饰，保证类不可new
    3定义静态方法使装载类可调用单例
 */

public class Mgr1 {
    public static final Mgr1 INSTANCE=new Mgr1();
    private Mgr1(){};
    public static Mgr1 getInstance(){
        return INSTANCE;
    }



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

Mgr2.java

package com.DP.singleton;

/**
 * 同Mgr1，写法稍微有所差异
 * 利用了静态语句块static{}初始化单例
 */
public class Mgr2 {
    public static final Mgr2 INSTANCE;
    static {
        INSTANCE=new Mgr2();
    }
    private Mgr2(){};
    public static Mgr2 getINSTANCE() {
        return INSTANCE;
    }

    //test
    public static void main(String[] args) {
        Mgr2 m1=Mgr2.getINSTANCE();
        Mgr2 m2=Mgr2.getINSTANCE();
        System.out.println(m1==m2);
    }
}

Mgr3.java

package com.DP.singleton;

/**
 * 单例模式-懒汉式
 * 使用时初始化，不使用不初始化单例
 * 缺点：虽然可按需初始化，但是会带来线程不安全
 * 要点同Mgr1
 */
public class Mgr3 {

    private static Mgr3 INSTANCE;
    private Mgr3(){}
    public static Mgr3 getINSTANCE() {
        if(INSTANCE==null){
            //防止线程创建过快，使得线程之间打断的几率增大
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }//仅供测试使用，非必要代码
            INSTANCE=new Mgr3();
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100;i++) {
            //线程安全性测试
            //同一个类的不同对象的hashcode是不同的，如果这100个线程hashcode相同表示该单例线程安全，否则不安全
                //补：哈希码相同也有可能不是同一对象
            //需要添加一些线程等待防止线程过快，使得hashcode没来得及变化
            new Thread(()-> System.out.println(Mgr3.getINSTANCE().hashCode())).start();//匿名类+lambda
//            new Thread(new Runnable() {
//                @Override
//                public void run() {
//                    System.out.println(Mgr3.getINSTANCE().hashCode());
//                }
//            }).start();//匿名类，两种方式选其一
        }
    }

Mgr4.java

package com.DP.singleton;

/**
 * 单例模式-懒汉式，同Mgr3
 * 按需初始化并解决其线程不安全的问题
 * 通过synchronized解决
 * 缺点：效率低下，对象大得多
 */
public class Mgr4 {

    private static Mgr4 INSTANCE;

    private Mgr4() {
    }
    public static synchronized Mgr4 getINSTANCE() {
        if (INSTANCE == null) {
            //防止线程创建过快，使得线程之间打断的几率增大
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }//仅供测试使用，非必要代码
            INSTANCE = new Mgr4();
        }
        return INSTANCE;
    }

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

Mgr5.java

package com.DP.singleton;

/**
 * 单例模式-懒汉式，试图改进Mgr4，提高效率
 * 按需初始化并解决其线程不安全的问题
 * 通过synchronized解决，并试图通过减小同步代码块的方式提高效率
 * 无法解决线程不安全问题
 * 不可行
 */
public class Mgr5 {

    private static Mgr5 INSTANCE;

    private Mgr5() {
    }

    public static Mgr5 getINSTANCE() {//不锁方法
        if (INSTANCE == null) {
            synchronized (Mgr5.class) {//反射，锁对象

                //防止线程创建过快，使得线程之间打断的几率增大
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }//仅供测试使用，非必要代码
                INSTANCE = new Mgr5();
            }
        }
        return INSTANCE;
    }

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

Mgr6.java

package com.DP.singleton;

/**
 * 单例模式-懒汉式，同Mgr4，懒汉式完美版-处女座专享
 * 按需初始化并解决其线程不安全的问题
 * 通过synchronized+双重if，相对提高效率
 * 缺点：代码不够简洁
 */
public class Mgr6 {

    private static volatile Mgr6 INSTANCE;//volatile防止指令重排

    private Mgr6() {
    }

    public static synchronized Mgr6 getINSTANCE() {
        if (INSTANCE == null) {//很有必要，不可省，否则每个线程还是都要加锁，省去一部分不为空的加锁过程（简而言之：不需要都等）
            synchronized (Mgr6.class) {
                if (INSTANCE == null){//双重检查
                //防止线程创建过快，使得线程之间打断的几率增大
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }//仅供测试使用，非必要代码
                INSTANCE = new Mgr6();
                }
            }
        }
        return INSTANCE;
    }

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

}

Mgr7.java

package com.DP.singleton;

/**
 * 静态内部类方式
 * JVM保证单例，Mgr7和Mgr7Holder都只会加载一次，一个class只加载一次
 * 加载外部类不会加载内部类，当调用getINSTANCE时才加载，实现了懒加载
 * 比Mgr1完美，可按需初始化
 */
public class Mgr7 {
    private Mgr7() {
    }
    private static class Mgr7Holder {
        public static final Mgr7 INSTANCE = new Mgr7();
    }

    public static Mgr7 getINSTANCE() {
        return Mgr7Holder.INSTANCE;//此时加载内部类
    }

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

Mgr8.java

package com.DP.singleton;

/**
 * 枚举单例
 * 《effective Java》
 * 来自Java创始人之一Joshua Bloch
 * 不仅可以解决线程同步还能防止反序列化
 * 不会被反序列化的原因：枚举类没有构造方法
 *NB plus
 * 厚积薄发
 */
public enum Mgr8 {
    INSTANCE;

    private void m(){}//单例方法

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> System.out.println(Mgr8.INSTANCE.hashCode())).start();//注意细微差别
        }
    }

}