Java设计模式：单例模式（程序员必知必会）——举例子+代码示例（通俗易懂）

单例模式：简单的说就是确保一个类仅有一个实例，减少实例创建与销毁的开销。

举个通俗的例子：我们电脑桌面上的一些软件快捷方式，我们可以创建多个这样的快捷方式，但是它们都是同一个，也就是说我们运行软件只有一个，其他地方只是引用这一个实例。

好了，有了例子打底后，

我们来看看通常情况下new实例化会创建新的一个对象，那么同理，new多个时也会创建多个新的对象。打印它的hashCode（相等的对象必须有相等的散列码即hashCode），会发现下面的hashCode不相同。

代码实例

class Singleton1{
   Singleton1(){}
}
public class demo1 {
    public static void main(String[] args) {
        System.out.println(new Singleton1().hashCode());
        System.out.println(new Singleton1().hashCode());
    }
}

运行结果

接下来我们来解决一下上面出现的问题，实现单例模式，单例模式又分为两种，一种是比较简单的饿汉式和问题比较多的懒汉式。

饿汉式

(饿汉式顾名思义，很冲动，一上来就开干)
可以看到代码的一个关键点：用private声明了构造方法，这样做其他类就不能直接通过new实例化了，我们知道一旦用private封装，就需要用get方式获取（搞这么多事情，其实就是为了由该类创建自己唯一的一个对象，然后不管后面多少类需要用到它，都杜绝了用new开辟新的实例浪费内存空间，通通都得用它这个唯一的，通过它的类然后调用get方法获取，这样保证全局的唯一性）

class Singleton2{
    private static final Singleton2 singleton = new Singleton2();

    private Singleton2(){}

    public static Singleton2 getSingleton(){
        return singleton;
    }
}

测试（可以看到相同的HashCode）

public class demo2 {
    public static void main(String[] args) {
        System.out.println( Singleton2.getSingleton().hashCode());
        System.out.println( Singleton2.getSingleton().hashCode());
    }
}

运行结果

上面的饿汉式实现了我们的单例模式，多线程下它是安全的，但是可以发现不管你有没有用到它，它都会一上来就建好给你，（类加载时就初始化）这样就会浪费了内存空间。

懒汉式

（懒汉式正好和饿汉式相反，没有饿汉式的冲动，有点懒，问题也多）
我们可以比较着来学，看懒汉式和饿汉式的它们的相同点和不同点，先看相同点：不管是懒汉式和饿汉式都有一个关键的代码是一样的，就是：私有化构造方法（这里你还问为什么的话，看上面饿汉式那里有解释），不同点是：没有一上来就new，而是在get方法里多了一个判断，如果还没实例化那么就实例化一个，如果实例化了，返回这个实例化好的。

详细看代码示例

class Singleton{
    private Singleton(){}
    private static Singleton instance;
    public static Singleton getInstance(){ 
        if(instance == null){
             instance =  new Singleton();
        }
        return instance;
    }
}
public class demo3 {
    public static void main(String[] args) {
        System.out.println(Singleton.getInstance().hashCode());
        System.out.println(Singleton.getInstance().hashCode());
    }
}

运行结果

可以看到现在懒汉式实现了单例模式，第一次调用才初始化，避免内存浪费，但是上面说了，懒汉式是有问题的，它多线程下是不同步的。我们来测试一下懒汉式多线程情况下

class Singleton{
    private Singleton(){
        System.out.println(Thread.currentThread().getName());
    }
    private static Singleton instance;
    public static Singleton getInstance(){
        if(instance == null){
             instance =  new Singleton();
        }
        return instance;
    }

}

public class demo3 {
    public static void main(String[] args) {
        //多线程下
        for(int i = 0;i<10;i++){
           new Thread(new Runnable(){
               @Override
               public void run() {
                   Singleton.getInstance();
               }
           }).start();
        }
    }
}

运行结果（结果是不一致）

那么怎么解决呢？用双检锁/双重校验锁（也称DCL）（你可能会疑问了，为什么不直接在get方法上加synchronized不也可以吗，是可以的，但是会影响性能，因为我们的目的只是针对实例执行一次这个关键的代码才需要同步，所以用双检锁可以安全且在多线程情况下保持高性能）

双检锁的代码示例，你可能还有一个疑问，为什么加上volatile关键字，有什么用呢？可以这么理解，用volatile解决指令重排的问题，因为new的时候不是原子性（什么是原子性很好理解，要么完整的执行，要么就完全的不执行，这是它的一个特性），我们创建的时候会经过这么一个过程，1.分配内存空间、2.执行构造方法，对象初始化、3.指针指向这个内存空间。正常情况一个线程是按着顺序123走的，但是当两个或多个线程出现，它就不一定会按着顺序来，那么就会出现一个指令重排的问题。（所以简单的理解volatile就是用来避免指令重排，不按顺序来）

class Singleton{
    private Singleton(){
        System.out.println(Thread.currentThread().getName());
    }
    private volatile static Singleton instance;
    public static Singleton getInstance(){
        if(instance == null){
            synchronized (Singleton.class){
                if (instance == null){
                    instance =  new Singleton();
                }
            }
        }
        return instance;
    }
}
public class demo3 {
    public static void main(String[] args) {
        //多线程下
        for(int i = 0;i<100;i++){
           new Thread(new Runnable(){
               @Override
               public void run() {
                   Singleton.getInstance();
                   Singleton.getInstance();
               }
           }).start();
        }
    }
}

运行结果（多次运行结果一致）

最后
到这里单例模式结束了吗，通常情况下是的，但看我之前发过的反射这篇文章：
Java高级特性——反射Reflection获取类的几种方式和利用反射对工厂模式解耦操作（代码示例）
可以知道，我们Java程序不只是通过new来创建或获取对象的，也可以用我们很强势的反射机制来，这里就留到我的下篇文章来吧，当单例遇到反射会碰出什么样的火花呢，敬请期待哦！