单例模式应该是设计模式中最好理解，比较简单的一种。单例模式分为两种 懒汉式和饿汉式两。
饿汉式是在程序编译过程中就进行对象创建，后来的使用只是对对象调用，所以不存在线程安全问题。

懒汉式

public class Singleton {
    // 创建静态实例化对象
    private static final Singleton instance = new Singleton();
    // 私有化构造方法
    private Singleton() {
    }
    // 提供静态的对外的对象获取方法
    public static Singleton getInstance() {
        return instance;
    }
}

懒汉式是在使用的时候去判断是否已经生成对象，如果是多线程的情况下，就会出现一种情况，线程1判断完对象还是null准备实例化，线程2也进行了判断而线程1还没实例化完成斗导致的后果就是实例化了2次，针对这种情况，要进行加锁。保证线程安全。

懒汉式单例加锁

public class Singleton2 {
public static Singleton2 Singleton=null;
private  Singleton2() {}
public  synchronized static Singleton2 getInstance(){
    if (Singleton==null) {
        return Singleton=new Singleton2();
    }
    return Singleton;
    }
}

保证了当多个进程进入第一个判断锁时，会被同步机制隔离，只有一个程序进入新建对象，再其他线程进入时，instance已经不为null，因此不会新建多个对象。但也有一个问题，就是java是实行无序写入的机制，在某个线程执行的过程中，instance被赋予了地址，但是singleton对象还没构造完成时，如果有线程访问了此时判断instance不为空，但是方法返回的是一个不完整对象的引用。此时可能会产生错误！

懒汉式单例双重加锁

public class Singleton3 {         //适用JDK1.5及以后
    private volatile static Singleton3 instance;
    private Singleton3() {
    }
    public static Singleton3 getInstance() {
        if (instance == null) {
            synchronized (Singleton3.class) {
                if (instance == null) {
                    instance = new Singleton3();//由于不是原子操作，禁止指令重排序优化，因此instance需要 volatile关键字修饰
                }
            }
        }
        return instance;
    }
}

还有一种静态内部类的方式，这里采用静态初始化的方式，它由JVM来保证线程安全性，当类装载的时候不去初始化对象，在这个内部类中去实例化对象，因此只要不使用内部类就不会创建对象，这样能解决线程安全的问题还可以实现延迟加载且不会增加任何访问开销

懒汉式单例静态内部

public class Singleton4 {
private  Singleton4() {}
private static  class SigletonHolder{
    private  static  Singleton4 instance=new Singleton4();
}
public static Singleton4 getInstance(){
    return SigletonHolder.instance;
    }
}