（一）单例模式

概念

单例模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

UML类图

单例模式.png

饿汉式（静态常量）

优点：在类进行装载的时候就完成实例化，避免了线程同步问题
缺点：如果没有使用到类，该类也会被装载进来，造成了内存浪费

public class Singleton1 {
    private final static  Singleton1 singleton1 =new Singleton1();
    private Singleton1(){
    }
    public static Singleton1 getInstence(){
        return singleton1;
    }
}

饿汉式（静态代码块）

优缺点与饿汉式通过静态变量一致

public class Singleton2 {
    private final static Singleton2 singleton2;
    static {
        singleton2=new Singleton2();
    }
    private Singleton2(){}
    public static Singleton2 getSingleton2(){
        return singleton2;
    }
}

懒加载（线程不安全）

适用于单线程，多线程情况下，一个线程还未判断结束时，另一个线程就开始加载，会导致产生多个实例，线程不安全，无法保证单例

public class Singleton3 {
    private static Singleton3 singleton3;
    private Singleton3(){}
    public static Singleton3 getSingleton3(){
        if (null==singleton3){
            singleton3=new Singleton3();
        }
        return singleton3;
    }
}

懒汉式（线程安全）

优点：线程安全
缺点：方法同步，效率低，每次调用该方法时，都要进行线程同步

public class Singleton4 {
    private static Singleton4 singleton4;
    private Singleton4(){}
    public static synchronized Singleton4 getSingleton4(){
        if (null==singleton4){
            singleton4=new Singleton4();
        }
        return singleton4;
    }
}

懒加载（同步代码块）

无实际意义，在多线程环境下，当多个线程同时进入到if判断中，会造成线程不安全

public class Singleton5 {
    private static Singleton5 singleton5;
    private Singleton5(){}
    public static Singleton5 getSingleton4(){
        if (null==singleton5){
            synchronized (Singleton5.class){
                singleton5=new Singleton5();
            }
        }
        return singleton5;
    }
}

懒加载（双重检查机制）

优点：解决了线程安全问题，也解决了效率问题；

public class Singleton6 {
    //volatile防止指令重排序问题，并且能将数据在主内存中修改
    private static volatile Singleton6 singleton6;
    private Singleton6(){}
    public static Singleton6 getSingleton4(){
        if (null==singleton6){
            synchronized (Singleton5.class){
                if (null==singleton6){
                    singleton6=new Singleton6();
                }
            }
        }
        return singleton6;
    }
}

静态内部类方式

静态内部类（Singleton）在外部类（Singleton7）加载时并不会将其加载出来，只有使用到静态内部类时才会加载，
类的静态属性只会在第一次加载类的时候初始化，jvm保证了线程的安全性

public class Singleton7 {
    private static Singleton7 singleton7;
    private Singleton7(){}
    //静态内部类
    private static class Singleton{
        private final static Singleton7 singleton7=new Singleton7();
    }
    public static  Singleton7 getSingleton7(){
        return Singleton.singleton7;
    }
}

枚举类方式

这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化，是线程安全，并不是懒加载。

public enum Singleton8 {
    INSTANCE;
    public void method(){
    }
}