目录地址
参考地址：单例的七中写法
单例模式简单来说就是只给这个类实例一个对象，所有的调用者均使用同一个对象对这个类进行操作。原文中写了七种方式，而文章中的第四种有错误，就没有贴出来。

一、懒汉式，线程不安全

这里说一下步骤：

• private构造方法（如果不做这一步的话，在调用时直接new就可以了，那么单例就接下来的操作就失去了意义）
• private静态的对象（存储该对象，方便调用）
• public静态的对象的方法（如果对象为空，新建后返回给；否则直接返回给用户）

/**
 * 单例:懒汉，线程不安全
 * Created by sjw on 2017/10/26.
 */

public class Singleton {
    private Singleton() {
    }
    private static Singleton singleton;
    public static Singleton instence(){
        if (singleton==null){
            singleton=new Singleton();
        }
        return singleton;
    }
}

说一下这个的缺点，无法再多线程里面应用。如果懂线程的大家应该就都懂，如果不懂的话也可以自行百度，在这里就不贴链接了。

二、懒汉式，线程安全

/**
 * 单例:懒汉，线程安全
 * Created by sjw on 2017/10/26.
 */
public class Singleton {
    private Singleton() {}
    private static Singleton singleton;
    public static synchronized Singleton instence(){
        if (singleton==null){
            singleton=new Singleton();
        }
        return singleton;
    }
}

这里大家会发现这个其实和第一个基本一样，只不过在获取方法（instence()）上加了一个synchronized线程锁。这样是可以在多线程中使用的。也许有人会说，既然这个这么好用，为什么还有第一个呢，简单的说，这种方法的效率很低下，所以一般不使用这种方法。

三、饿汉式

public class Singleton {
    private Singleton() {
    }
    private static Singleton singleton=new Singleton();
    public static synchronized Singleton instence(){
        return singleton;
    }
}

这种方法也可以避免了第一种多线程的尴尬，而且也没有第二种效率低下的限制。但是，这种方法也有着他的问题，因为我们可以看到，这个类的对象是在类加载的时候就已经实例了。原文中说的是因为类加载器的原因，但我觉得如果使用不同的类加载器加载出的两个类，即使是方式1中也会出现两个不同的对象。所以，在经过查阅资料进行对比之后，懒汉和饿汉的本质区别是加载的时机不同。由于表达能力实在有限，这里引用百度百科里的回答：

单例中懒汉和饿汉的本质区别在于以下几点：
1、饿汉式是线程安全的, 在类创建的同时就已经创建好一个静态的对象供系统使用,以后不在改变。 懒汉式如果在创建实例对象时不加上synchronized则会导致对对象的访问不是线程安全的。
2、从实现方式来讲他们最大的区别就是懒汉式是延时加载, 他是在需要的时候才创建对象, 而饿汉式在虚拟机启动的时候就会创建， 饿汉式无需关注多线程问题、 写法简单明了、 能用则用。 但是它是加载类时创建实例(上面有个朋友写错了)、 所以如果是一个工厂模式、 缓存了很多实例、 那么就得考虑效率问题， 因为这个类一加载则把所有实例不管用不用一块创建。

四、静态内部类

/**
 * 单例:静态内部类
 * Created by sjw on 2017/10/26.
 */

public class Singleton {
    private Singleton() {
    }
    private static class SingletonHolder{
        private static final Singleton SINGLETON=new Singleton();
    }
    
    public static final Singleton instence() {
        return SingletonHolder.SINGLETON;
    }
}

静态内部类的方式，保证了加载方式如饿汉一样具有线程的安全。同样也避免了饿汉式在类被加载时就创建对象的尴尬。这是是在我们初次调用instence()方法时，加载SingletonHolder类时才会创建Singleton的对象。

五、枚举

枚举的方式我确实是第一次才知道，在经过试验后发现真的很方便。下面是代码：

 /**
 * 单例:枚举
 * Created by sjw on 2017/10/26.
 */

public enum  Singleton {
     INSTANCE;
     public String whateeverMethod(){
         return "ABC";
     }
}

其实我在看原文时，还有些尴尬的。因为我完全看不懂，确切说是不知道如何使用，于是我查阅了资料（枚举使用详解）。文章最后提出enum其实和class是一样的，之不过enum是继承了 java.lang.Enum类而已。因为了解的不多，这里就不说了。
于是我进行了测试：

枚举的调用

Singleton.INSTANCE.whateeverMethod()

而且我在（单例模式）中读到：

这种实现方式(枚举)还没有被广泛采用， 但这是实现单例模式的最佳方法。 它更简洁， 自动支持序列化机制， 绝对防止多次实例化。
这种方式是 Effective Java 作者 Josh Bloch 提倡的方式， 它不仅能避免多线程同步问题， 而且还自动支持序列化机制， 防止反序列化重新创建新的对象， 绝对防止多次实例化。 不过， 由于 JDK1.5 之后才加入 enum 特性， 用这种方式写不免让人感觉生疏， 在实际工作中， 也很少用。 不能通过 reflection attack 来调用私有构造方法。

文中提到这是实现单例最好的方式。也提出了这是在JDK1.5之后加入的，不过我认为在我们开发中已经很难遇到jdk1.5以下的版本了吧。因此，我认为还是可以尝试使用的。

六、双重校检锁

/**
 * 单例:双重校检锁
 * Created by sjw on 2017/10/26.
 */
public class Singleton {
    private volatile static Singleton singleton;
    private Singleton() {
    }
    public static Singleton getSingleton() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }

这种方式保证了是对方式2的升级。主要是改变加锁位置，提高效率。

总结

算了，总结以后再读的时候再写吧。
目录地址