单例设计模式：

某个类在整个系统中只能有一个实例，对象可被获取和使用的代码模式。
例如：代表jvm运行环）境的Runtime类
单例模式共有的特点：1）构造器私有化 2） 有个静态变量去保存 3）提供方法区获取这个变量

单例模式分为懒汉式和饿汉式。下面分别介绍懒汉式和饿汉式的几种写法。

饿汉式第一种（jdk1.5之前）：

public class Singleton1 {

    public final static Singleton1 INSTANCE = new Singleton1();
    private Singleton1(){
    }
}

我们可以直接使用Singleton1.INSTANCE 就可以获取到这个单例对象。

饿汉式第二种（jdk1.5之后），枚举：

public enum Singleton2 {
    INSTANCE;
}

我们可以直接使用Singleton2.INSTANCE 就可以获取到这个单例对象。枚举的构造器默认就为私有的，所以满足我们的条件。

饿汉式第三种，使用静态代码块初始化

public class Singleton3 {

    public final  static Singleton3 INSTANCE;
    private   String info;
    static {
        Properties properties = new Properties();
        try {
            properties.load(Singleton3.class.getClassLoader().getResourceAsStream("info.properties"));
        } catch (IOException e) {
            e.printStackTrace();
        }

         String mStr  = (String) properties.get("info");
        INSTANCE = new Singleton3();
        INSTANCE.setInfo(mStr);
    }
    private Singleton3(){

    }
    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return super.toString();
    }
}

这种适用于有些变量需要在单例对象前初始化。
饿汉式不涉及到线程安全问题，因为饿汉式都是在类初始化的时候初始化类变量，类加载机制可以避免线程安全问题。

懒汉式（延迟加载）

懒汉式第一种（线程不安全）：

public class Singleton4 {

    private static  Singleton4 instance ;

    private Singleton4(){

    }
    public static Singleton4 getInstance(){
        if (instance == null){
          instance = new Singleton4();
        }
        return instance;
    }
}

调用类的getInstance方法即可获取到单例对象。
懒汉式第二种（线程安全）：

public class Singleton5 {

    private static Singleton5 instance ;

    private Singleton5(){

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

为代码块加上同步锁，来保证线程安全。
懒汉式第三种（线程安全，使用内部类）

/*
 * 在内部类被加载和初始化时，才创建INSTANCE实例对象
 * 静态内部类不会自动随着外部类的加载和初始化而初始化，它是要单独去加载和初始化的。
 * 因为是在内部类加载和初始化时，创建的，因此是线程安全的
 */
public class Singleton6 {
    private Singleton6(){

    }
    private static class Inner{
        private static final Singleton6 INSTANCE = new Singleton6();
    }
    public static Singleton6 getInstance(){
        return Inner.INSTANCE;
    }
}

这种方法看起来代码更为简洁，且利用类加载机制来保证了线程的安全。