单例模式的学习总结

单例模式

1. 意图：在某些应用场景中，对于某个类只能产生一个对象；
2. 原理
   1、构造器私有化；
   2、定义该类的类变量，数据类型就是该类
   3、提供公共的访问方式，用于获取(创建)对象，并且该公共的访问方式必须是静态，并且在公共
   的访问方式中不能再直接通过new关键字创建该类的对象
3. 两种单例模式
   1、懒汉式：上述2中的类变量在定义时不进行初始化，在公共的访问方法中进行判断和初始化懒汉式单例模式的优化，通过同步代码块的外面再加一层判断，判断上述的类变量是否为null，如果为null，则继续执行，不为null，则通过return语句获取
   2、饿汉式：上述2中类变量在定义时就进行初始化，为了保证单例模式，对该类变量再次使用final修饰

**懒汉式**
class Util{
    //构造器私有化
    private Util(){}
    //类变量用用于接收本类的对象
    //在定义类变量时不进行初始化
    private static Util u;

    //提供公共的访问方式
//    public static Util getInstance(){
//        if (u == null){
//            try {
//                Thread.sleep(1000);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            u = new Util();
//        }
//        return u;
//    }
    //对上述方法进行优化
    public static Util getInstance(){
        if (u == null){
            synchronized (Util.class){
                if (u == null){
                    u = new Util();
                }
            }
        }
        return u;
    }
}
**饿汉式**
class Tool{
    //构造器私有
    private Tool(){}

    //t处于静态区，指向堆内存中的new Tool()，唯一
    public static final Tool t = new Tool();
}

//测试类
public class SingleObjectDemo {
    public static void main(String[] args) {
        long ot = System.currentTimeMillis();
        SingleObject singleObject = SingleObject.getInstance();
        singleObject.show();
        long nt = System.currentTimeMillis();
        System.out.println(nt - ot);

        long ot1 = System.currentTimeMillis();
        SingleObject1 so1 = SingleObject1.getInstance();
        so1.show();
        long nt1 = System.currentTimeMillis();
        System.out.println(nt1 - ot1);

        long ot2 = System.currentTimeMillis();
        SingleObject2 instance = SingleObject2.getInstance();
        instance.show();
        long nt2 = System.currentTimeMillis();
        System.out.println(nt2 - ot2);

        long ot3 = System.currentTimeMillis();
        SingleObject3 so3 = SingleObject3.getInstance();
        so3.show();
        long nt3 = System.currentTimeMillis();
        System.out.println(nt3 - ot3);

        long ot4 = System.currentTimeMillis();
        SingleObject4 so4 = SingleObject4.INSTANCE;
        so4.show();
        long nt4 = System.currentTimeMillis();
        System.out.println(nt4 - ot4);
    }
}

//线程安全，效率高，浪费内存,饿汉式
class SingleObject{
    //构造私有
    private SingleObject(){}

    //创建SingleObject的唯一对象
    private static final SingleObject so = new SingleObject();

    //获取唯一可用对象
    public static SingleObject getInstance(){
        return so;
    }

    public void show(){
        System.out.println("这是单例模式的饿汉式");
    }
}

//线程安全效率低，懒汉式
class SingleObject1{
    //构造私有
    private SingleObject1(){}

    private static SingleObject1 so;

    //提供公共方法获取对象
    public static SingleObject1 getInstance(){
        if (so == null){
            synchronized (SingleObject1.class){
                if (so == null){
                    so = new SingleObject1();
                }
            }
        }
        return so;
    }

    public void show(){
        System.out.println("这是单例模式中的懒汉式，线程安全");
    }
}

//这种方式采用双锁机制，安全且在多线程情况下能保持高性能。懒汉双锁机制式
class SingleObject2{
    private SingleObject2(){}

    //volatile可以让该数据在线程中可见，一旦改变，其他线程会立刻得到改变后的值，适用于读多写少的数据
    private volatile static SingleObject2 instace;

    public static SingleObject2 getInstance(){
        if (instace == null){
            synchronized (SingleObject2.class){
                if (instace == null){
                    instace = new SingleObject2();
                }
            }
        }
        return instace;
    }

    public void show(){
        System.out.println("这是存在双锁机制的单例模式");
    }
}

//采用静态内部类来实现单例模式，线程安全，饿汉静态内部类式
class SingleObject3{
    private static class Inner{
        private static final SingleObject3 instance = new SingleObject3();
    }
    //构造私有
    private SingleObject3(){}

    public static SingleObject3 getInstance(){
        return Inner.instance;
    }

    public void show(){
        System.out.println("这是内部类的形式的单例模式");
    }
}

//单例模式的最佳方式，枚举式
enum SingleObject4{
    INSTANCE;

    public void show(){
        System.out.println("这是单例模式最好的方式——枚举");
    }
}