设计模式-01单例设计模式

01单例设计模式

基本介绍

所谓类的单例设计模式,就是采取一定的方法保证在整个软件系统中,对某个类只能存在一个对象实例,
并且该类只提供一个取得其对象实例的方法(静态方法)。

比如Hibernate中的SessionFactory,它充当的就是数据存储源的代理,并负责创建Session对象。
SessionFactory并不是轻量级的,一般情况下,一个项目只需要一个SessionFactory就够,这时就需要单例设计模式。

• 单例设计模式有8种写法

饿汉式(静态常量)

• 优点: 这种写法比较简单,就是在类装载的时候就完成了实例化。避免了线程同步的问题。
• 缺点: 在类装载的时候就完成初始化,没有达到Lazy Loading的效果。如果从始至终没有使用过这个实例就会造成内存的浪费。
• 这种方式基于ClassLoder机制避免了多线程同步问题,不过instance在类装载的时候就实例化,在单例模式中,一般都是调用getInstance()获取单例对象,但是导致类装载的原因有很多不确定因素,比如使用了该类的其他静态方法,因此就会造成资源浪费。

public class SingletonTest01 {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }
}


/**
 - 饿汉式-静态变量
 */
class Singleton {

    /**
     * 1.私有化构造器,让外部不能new
     */
    private Singleton() {
    }

    /**
     * 2.本类中创建静态常量实例
     */
    private final static Singleton instance = new Singleton();

    /**
     * 3. 对外提供一个方法,返回单例对象
     *
     * @return 单例对象
     */
    public static Singleton getInstance() {
        return instance;
    }
}

饿汉式(静态代码块)

• 这种方式和上面的代码很相似,只不过将初始化放在了静态代码块中,也是在类装载的时候初始化,优点缺点和上面是一样的。

public class SingletonTest02 {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }
}


/**
 * 饿汉式-静态代码块
 */
class Singleton {

    /**
     * 1.私有化构造器,让外部不能new
     */
    private Singleton() {
    }

    /**
     * 2.本类中申请静态常量
     */
    private final static Singleton instance;

    /*
      3.使用静态代码块创建单例对象
     */
    static {
        instance = new Singleton();
    }

    /**
     * 4. 对外提供一个方法,返回单例对象
     *
     * @return 单例对象
     */
    public static Singleton getInstance() {
        return instance;
    }
}

懒汉式(线程不安全)

public class SingleTonTest03 {
    public static void main(String[] args) {
        SingleTon instance = SingleTon.getInstance();
        System.out.println(SingleTon.getInstance() == instance);
    }
}

class SingleTon {
    private static SingleTon instance;

    private SingleTon() {

    }

    /**
     * 懒汉式,在使用的时候才创建对象,但是这是线程不安全的
     * 在高并发极端情况下有可能会覆盖创建
     * 一个线程判断if为true的时候,另一个线程也判断if为true,就覆盖了
     *
     * @return 单例
     */
    public static SingleTon getInstance() {
        if (instance == null) {
            instance = new SingleTon();
        }
        return instance;
    }
}

懒汉式(线程安全,同步方法)

public class SingleTonTest04 {
    public static void main(String[] args) {
        SingleTon instance = SingleTon.getInstance();
        System.out.println(SingleTon.getInstance() == instance);
    }
}

class SingleTon {
    private static SingleTon instance;

    private SingleTon() {

    }

    /**
     * 懒汉式,在使用的时候才创建对象,但是这是线程不安全的
     * 使用synchronized,解决线程安全问题,但是synchronized效率不高
     *
     * @return 单例
     */
    public static synchronized SingleTon getInstance() {
        if (instance == null) {
            instance = new SingleTon();
        }
        return instance;
    }
}

懒汉式(线程安全,同步代码块)

public class SingleTonTest04 {
    public static void main(String[] args) {
        SingleTon instance = SingleTon.getInstance();
        System.out.println(SingleTon.getInstance() == instance);
    }
}

class SingleTon {
    private static SingleTon instance;

    private SingleTon() {

    }

    /**
     * 懒汉式,给创建单例对象的new 加同步,其实这样根本没用     
     *
     * @return 单例
     */
    public static SingleTon getInstance() {
        if (instance == null) {
            synchronized (SingleTon.class) {
                instance = new SingleTon();
            }
        }
        return instance;
    }
}

双重检查

public class SingleTon06 {
    public static void main(String[] args) {
        SingleTon instance = SingleTon.getInstance();
        System.out.println(instance == SingleTon.getInstance());
    }
}

class SingleTon {
    // 使用volatile,立即更新变量到主存
    private static volatile SingleTon instance;

    private SingleTon() {

    }

    // 先判断是否为空, 再次判断是否为空,双重检查
    public static SingleTon getInstance() {
        if (instance == null) {
            synchronized (SingleTon.class) {
                if (instance == null) {
                    instance = new SingleTon();
                }
            }
        }
        return instance;
    }
}

静态内部类

public class SingleTon07 {
    public static void main(String[] args) {
        SingleTon instance = SingleTon.getInstance();
        System.out.println(instance == SingleTon.getInstance());
    }
}

class SingleTon {
    private SingleTon() {
    }

    // 使用类加载机制创建单例对象,只有在调用getInstance方法的时候才会装载这个类
    public static class SingleTonInstance {
        private static final SingleTon INSTANCE = new SingleTon();
    }

    public static SingleTon getInstance() {
        return SingleTonInstance.INSTANCE;
    }
}

枚举

public class SingleTon08 {
    public static void main(String[] args) {
        SingleTon instance1 = SingleTon.INSTANCE;
        SingleTon instance2 = SingleTon.INSTANCE;
        System.out.println(instance1 == instance2);

        instance1.sayOk();
    }
}

/**
 * 使用枚举的特性,也可以创建单例
 */
enum SingleTon {
    INSTANCE;

    public void sayOk() {
        System.out.println("ok");
    }
}