重学设计模式-单例模式

愿你生命中有够多的云翳，造就一个美好的黄昏 

 　　

介绍

　　单例模式是指一个类在整个程序运行中只允许存在一个实例，也就是说在JVM里面只存在一个实例，单例模式应用十分广泛，比如说一个公司里面只有一个CEO，一个家庭里面只有一个爸爸（当然，排除那些意外），单例模式主要应用在需要频繁使用创建和使用的一些类上面，因为只存在一个实例，所以节省了内存的开销，所有线程共享同一个实例，试想一下，如果一个类使用十分频繁，没有使用单例模式的情况下，一个线程需要创建一个实例，那么系统中将会出现出现很多多余的实例，对内存的消耗也很大，JVM中容易发生GC，比如数据库连接池，某些不太常用的对象，皆可使用单例模式来做，有助于提高系统的可用性。

单例模式的种类

　　单例模式有很多种写法，大致可分为线程安全和线程不安全，下面我们来看一下具体的种类以及实现方式。

　　一.饿汉式单例模式

　　饿汉式顾名思义就是很饿，想要马上得到，正如一个饥渴已久的汉子一样，想要马上得到爱情的滋养，换到程序里面来也一样，一个对象在程序启动时就进行初始化，创建一个单例对象，也就是说程序已启动，他马上进行实例化，JVM就存在一个单例对象，后面就不会再创建，它是线程安全的，因为后面的线程来访问的时候，实例已经存在，直接使用就行，不用再去实例化，所以它的效率非常高，但是凡事有利有弊，我们已经看出，再系统启动时就进行就对对象进行初始化，那么如果这个实例使用并不是很多，那会造成内存的浪费，如果系统中存在大量的单例对象，那么使用饿汉式可能就不是那么合理啦，下面来具体实现一下饿汉式。

package SinglePattern.HungryMan;

public class HungryManSingleton {

    private static HungryManSingleton hungryManSingleton = new HungryManSingleton();

    public HungryManSingleton(){}

    public static HungryManSingleton getInstance(){
        return hungryManSingleton;
    }
}

　    我们看执行结果，开启多个线程，不管怎么执行，获取到的都是同一个实例，因为在程序启动时就已经做了初始化操作，JVM已经存在这个实例，所以使用的就是这个实例。

package SinglePattern.HungryMan;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

public class Client {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                HungryManSingleton instance = HungryManSingleton.getInstance();
                System.out.println("instance1   "+instance);
            }
        });
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                HungryManSingleton instance = HungryManSingleton.getInstance();
                System.out.println("instance2   "+instance);
            }
        });
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                HungryManSingleton instance = HungryManSingleton.getInstance();
                System.out.println("instance3   "+instance);
            }
        });
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                HungryManSingleton instance = HungryManSingleton.getInstance();
                System.out.println("instance4   "+instance);
            }
        });

        executorService.shutdown();

    }
}

　

　    二.懒汉式单例模式

　　懒汉式顾名思义就是很懒，现实生活中的懒汉都是火烧到自家门前才着急，在我们农村老人有这样一句话，屎要拉出来了才想到挖茅坑，这样的比喻应该恰当吧，换到程序里面来，有很多例子，比如前端的树结构懒加载，不会一下子将所有子节点都遍历出来，而是点击那一层，再加载出下级，懒汉式就是运用这样的思想，需要用的时候我再加载，这样的好处是节省内存空间，如果一个对象不经常用，我们就不需要在程序初始化时就将其加载，但是它会出现线程安全问题，具体看代码。

package SinglePattern.LazyMan;

public class LazyManSingleton {
    private static LazyManSingleton lazyManSingleton = null;
    public static LazyManSingleton getInstance(){
        if (lazyManSingleton == null){
            lazyManSingleton = new LazyManSingleton();
        }
        return lazyManSingleton;
    }
}

 　　如图可知，给对象一个初始值为空，如果线程访问的时候，判断到对象是空的，则进行实例化，当第二个线程访问的时候，因为第一个线程已经进行实例化，所以直接返回，而不用再进行实例化，那么会有一种情况，如果两个或者两个以上的线程同时访问呢，当多个线程跑到判空条件那里时，当第一个线程还没有完成创建对象，第二个线程判断到对象依然为空，所以进行创建，这样，就会创建两个对象，所以是线程不安全的，我们看下结果。

　　

 　　运行多次以后，我们发现创建了两个对象，那么如何避免这种情况呢，当然有方法，我们可以使用加锁的方式来实现线程安全问题，如下。

package SinglePattern.LazyMan;

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

 　　我们使用了同步阻塞锁synchronized锁来同步方法，这样，每个线程访问时都要等待当前线程访问完成后才能进行访问，那么其中就有一个问题，明明只需要一个线程创建对象后其他线程就能使用，而现在，明明对象已经创建完成了，只需要判断一下就返回对象，但是我一堆线程还阻塞在外面，只是为了一个判断，这是很不合理的，没事，我们继续改进。

　　三.双重校验锁（DCL）

　　懒汉式加锁可以实现线程安全，但是其效率很低，所以我们使用了双重锁校验，代码如下。

package SinglePattern.DCL;

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

}

 　　我们从上面代码中可以看出，使用了两次if判断，我们解读一下，如果此时对象还没有进行实例化，还为null，此时两个线程同时访问，两个线程同时进入了第一个if语句，但是到了同步代码块这里的时候第一个线程进入了同步代码块，第二个线程被阻塞了，当第一个线程实例化完成以后，第二个线程进入同步代码块以后判断instance不为空，则直接跳出判断，返回实例，后续的线程通过第一个判断，就直接返回，这样效率就会变得很高，也不存在线程安全问题。

　　四.静态内部类实现

　　上面我们使用了双重做校验方式实现了单例模式，在线程安全和效率上面都很不多，但是我们依然使用同步锁，那么还有没有更加优雅，效率更高的写法呢，答案是肯定有的，我们可以利用java的一些特性来实现，这里就使用了静态内部类，我们知道，java的内部类会在外部类执行前先执行，这样我们就可以在内部类里面进行实例化，然后外部类获取实例，代码如下。

package SinglePattern.StaticInsideClass;

public class StaticInsideClassSingleton {
    private static class SingleHolder{
        private static final StaticInsideClassSingleton INSTANCE = new StaticInsideClassSingleton();
    }
    private StaticInsideClassSingleton(){

    }
    public static StaticInsideClassSingleton getInstance(){
        return SingleHolder.INSTANCE;
    }
}

 　　因为在初始化的时候静态内部类已经完成对象的实例化，所以不存在线程安全问题。

　　五.使用枚举

　　这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于 JDK1.5 之后才加入 enum 特性，这种方式能够防止反射攻击（上面几种都可以通过反射来获取类的私有构造函数，从而能够创建多个实例），而enum可以防止。

package SinglePattern.Enum;

public enum EnumSingle {
    INSTANCE;

    public static EnumSingle getInstance(){
        return INSTANCE;
    }
}

 

package SinglePattern.Enum;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Client {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                EnumSingle instance = EnumSingle.getInstance();
                System.out.println("instance1  "+instance.hashCode());
            }
        });
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                EnumSingle instance = EnumSingle.getInstance();
                System.out.println("instance2  "+instance.hashCode());
            }
        });
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                EnumSingle instance = EnumSingle.getInstance();
                System.out.println("instance3  "+instance.hashCode());
            }
        });
        executorService.shutdown();
    }
}