创建者模式-01单例模式

一、单例设计模式

1. 定义

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

2. 方式

2.1 饿汉式（静态常量）

1. 步骤

1. 构造器私有化(防止new)
2. 类的内部创建对象

2. 代码

class singleT {
    //1.初始化私有构造器，不能被实例化
    private singleT() {

    }

    //2.创建一个静态的最终对象
    private static final singleT ton = new singleT();

    //3.提供一个公有的方法并返回2中的对象
    public static singleT getT() {
        return ton;
    }
}

• 测试

public class singleTest {
    public static void main(String[] args) {
        //测试：不管实例化哪个都只是那一个，hashCode一样
        singleT ton = singleT.getTon();
        singleT ton1 = singleT.getTon();
        System.out.println(ton.hashCode());
        System.out.println(ton1.hashCode());
        System.out.println(ton == ton1);
    }
}

1163157884
1163157884
true

3. 优缺点

1. 优点：在类装载的时候就完成实例化。避免了线程同步问题。
2. 缺点：在类装载的时候就完成实例化，如果从始至终从未使用过这个实例，则会造成内存的浪费
3. 容易可能造成内存浪费

2.2 饿汉式（静态代码块）

1. 步骤

• 和2.1类似

2. 代码

class singleTon {
    //1.初始化私有构造器，不能被实例化
    private singleT() {

    }

    //2.创建一个静态的最终对象
    private static final singleT ton;

    static {
        ton = new singleT();
    }

    //3.提供一个公有的方法并返回2中的对象
    public static singleT getTon() {
        return ton;
    }
}

3. 优缺点

• 同上

2.3 懒汉式（双重检查）

1. 代码

class singleDoubleCheck {
    private singleDoubleCheck() {
    }

    //轻量级的synchornized
    private static volatile singleDoubleCheck stNS;

    public static singleDoubleCheck getStNS() {

        if (stNS == null) {
            /**
             * 假设有A，B，C三个线程同时执行到此
             */
            //1.若A先进来执行完了也new完了，B以后的都不会满足内部的if条件
            synchronized (singleDoubleCheck.class) {
                if (stNS == null) {
                    stNS = new singleDoubleCheck();
                }
            }
        }
        return stNS;
    }
}

2. 优缺点

1. Double-Check概念是多线程开发中常使用到的，如代码中所示，我们进行了两 次if (singleton == null)检查，这样就可以保证线程安全了。
2. 这样，实例化代码只用执行一次，后面再次访问时，判断if (singleton == null)， 直接return实例化对象，也避免的反复进行方法同步.
3. 线程安全；延迟加载；效率较高
4. 在实际开发中，推荐使用这种单例设计模式

2.4 懒汉式（静态内部类）

1. 代码

class staticInnerClass {
    private staticInnerClass() {
    }

    private static volatile staticInnerClass stNS;

    //创建一个类，采用类加载机制保证实例化只有一个线程
    private static class  SingleInstance{
        private static final staticInnerClass INNER_CLASS = new staticInnerClass();
    }
    public static staticInnerClass getStNS() {
        return SingleInstance.INNER_CLASS;
    }
}

2. 优缺点

1. 这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
2. 静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化 时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的 实例化。
3. 类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们 保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
4. 优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高
5. 结论：推荐使用.

2.5 懒汉式（枚举）

1. 代码

enum SinleEnum{
    INSTANCE;
    public void ready(){
        System.out.println("ok");
    }
}

• 测试代码

public static void main(String[] args) {
    SinleEnum instance1 = SinleEnum.INSTANCE;
    SinleEnum instance2 = SinleEnum.INSTANCE;
    System.out.println(instance1==instance2);
    System.out.println(instance1.hashCode());
    System.out.println(instance2.hashCode());
}

true
1163157884
1163157884

2. 优缺点

1. 这借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而 且还能防止反序列化重新创建新的对象。
2. 这种方式是Effective Java作者Josh Bloch 提倡的方式
3. 结论：推荐使用