关于java:Java设计模式一单例模式

package com.nasuf.pattern.singleton;/** * 单例模式 */public class Test {    public static void main(String[] args) {        Singleton1 singleton1 = Singleton1.getInstance();        Singleton1 singleton2 = Singleton1.getInstance();        System.out.println(singleton1 == singleton2);   // true        System.out.println(singleton1.hashCode());  // 621009875        System.out.println(singleton2.hashCode());  // 621009875    }}/** * 饿汉式一 * 长处：简略，在类加载时实现实例化，防止了线程同步问题 * 毛病：在类加载时实现实例化，没有达到懒加载成果，如果从未应用过这个实例，则会造成内存节约 */class Singleton1 {    private Singleton1() {    }    private final static Singleton1 instance = new Singleton1();    public static Singleton1 getInstance() {        return instance;    }}/** * 饿汉式二 * 长处：简略，在类加载时实现实例化，防止了线程同步问题 * 毛病：在类加载时实现实例化，没有达到懒加载成果，如果从未应用过这个实例，则会造成内存节约 */class Singleton2 {    private Singleton2() {    }    private static Singleton2 instance;    static {        instance = new Singleton2();    }    public static Singleton2 getInstance() {        return instance;    }}/** * 懒汉式一 * 长处：懒加载成果 * 毛病：线程不平安，只能利用在单线程状况下 */class Singleton3 {    private Singleton3() {    }    private static Singleton3 instance;    public static Singleton3 getInstance() {        if (instance == null) {            instance = new Singleton3();        }        return instance;    }}/** * 懒汉式二 * 长处：懒加载成果，线程平安 * 毛病：效率低，每个线程在想取得类的实例时，执行getInstance办法都要进行同步 */class Singleton4 {    private Singleton4() {    }    private static Singleton4 instance;    public static synchronized Singleton4 getInstance() {        if (instance == null) {            instance = new Singleton4();        }        return instance;    }}/** * 懒汉式三 * 毛病：线程不平安，效率低，每个线程在想取得类的实例时，执行getInstance办法都要进行同步 */class Singleton5 {    private Singleton5() {    }    private static Singleton5 instance;    public static Singleton5 getInstance() {        if (instance == null) {            synchronized (Singleton5.class) {                instance = new Singleton5();            }        }        return instance;    }}/** * 双重查看（举荐应用） */class Singleton6 {    private Singleton6() {    }    private static volatile Singleton6 instance;    public static Singleton6 getInstance() {        if (instance == null) {            synchronized (Singleton6.class) {                if (instance == null) {                    instance = new Singleton6();                }            }        }        return instance;    }}/** * 动态外部类（举荐应用） * 外部类装载时，动态外部类不会被装载；外部类只会被装载一次，在类进行初始化时，其余线程无奈进入 * 保障了线程平安； */class Singleton7 {    private Singleton7() {    }    private static class SingletonInstance {        private static final Singleton7 INSTANCE = new Singleton7();    }    public static synchronized Singleton7 getInstance() {        return SingletonInstance.INSTANCE;    }}/** * 枚举（举荐应用） * 线程平安，避免反序列化从新创立新的对象 * 应用：Singleton8 instance = Singleton.INSTANCE */enum Singleton8 {    INSTANCE;}