单例模式介绍
单例模式是指一个类在整个程序运行时只允许存在一个实例，也就是说在JVM里面只存在一个实例，单例模式应用十分广泛，比如说一个公司里面只有一个CEO，一个家庭里面只有一个爸爸（当然，排除那些意外），单例模式主要应用在需要频繁使用创建和使用的一些类上面，因为只存在一个实例，所以节省了内存的开销，所有线程共享同一个实例，试想一下，如果一个类使用十分频繁，没有使用单例模式的情况下，一个线程需要创建一个实例，那么系统中将会出现出现很多多余的实例，对内存的消耗也很大，JVM中容易发生GC，比如数据库连接池，某些不太常用的对象，皆可使用单例模式来做，有助于提高系统的可用性。
单例模式种类
单例模式有很多种写法，大致可分为线程安全和线程不安全，下面我们来看一下具体的种类以及实现方式。
一.饿汉式单例模式
饿汉式顾名思义就是很饿，想要马上得到，正如一个饥渴已久的汉子一样，想要马上得到爱情的滋养，换到程序里面来也一样，一个对象在程序启动时就进行初始化，创建一个单例对象，也就是说程序已启动，他马上进行实例化，JVM就存在一个单例对象，后面就不会再创建，它是线程安全的，因为后面的线程来访问的时候，实例已经存在，直接使用就行，不用再去实例化，所以它的效率非常高，但是凡事有利有弊，我们已经看出，再系统启动时就进行就对对象进行初始化，那么如果这个实例使用并不是很多，那会造成内存的浪费，如果系统中存在大量的单例对象，那么使用饿汉式可能就不是那么合理啦，下面来具体实现一下饿汉式。
代码语言：javascript复制public class HungryManSingleton {
private static final HungryManSingleton hungryManSingleton = new HungryManSingleton();
public HungryManSingleton(){}
public static HungryManSingleton getInstance(){
return hungryManSingleton;
}
}我们看执行结果，开启多个线程，不管怎么执行，获取到的都是同一个实例，因为在程序启动时就已经做了初始化操作，JVM已经存在这个实例，所以使用的就是这个实例。
代码语言：javascript复制public class Client {
public static void main(String[] args) {
new Thread(() -> {
HungryManSingleton instance = HungryManSingleton.getInstance();
System.out.println("instance1 " instance);
}).start();
new Thread(() -> {
HungryManSingleton instance = HungryManSingleton.getInstance();
System.out.println("instance2 " instance);
}).start();
}
}
输出：
instance1 designpattern.single.HungryMan.HungryManSingleton@22ff7883
instance2 designpattern.single.HungryMan.HungryManSingleton@22ff7883二.懒汉式单例模式
懒汉式顾名思义就是很懒，现实生活中的懒汉都是火烧到自家门前才着急，在我们农村老人有这样一句话，屎要拉出来了才想到挖茅坑，这样的比喻应该恰当吧，换到程序里面来，有很多例子，比如前端的树结构懒加载，不会一下子将所有子节点都遍历出来，而是点击那一层，再加载出下级，懒汉式就是运用这样的思想，需要用的时候我再加载，这样的好处是节省内存空间，如果一个对象不经常用，我们就不需要在程序初始化时就将其加载，但是它会出现线程安全问题，具体看代码。
代码语言：javascript复制public class LazyManSingleton {
private static LazyManSingleton lazyManSingleton = null;
public static LazyManSingleton getInstance(){
if (lazyManSingleton == null){
lazyManSingleton = new LazyManSingleton();
}
return lazyManSingleton;
}
}如图可知，给对象一个初始值为空，如果线程访问的时候，判断到对象是空的，则进行实例化，当第二个线程访问的时候，因为第一个线程已经进行实例化，所以直接返回，而不用再进行实例化，那么会有一种情况，如果两个或者两个以上的线程同时访问呢，当多个线程跑到判空条件那里时，当第一个线程还没有完成创建对象，第二个线程判断到对象依然为空，所以进行创建，这样，就会创建两个对象，所以是线程不安全的，我们看下结果。
代码语言：javascript复制public class Client {
public static void main(String[] args) throws InterruptedException {
new Thread(() -> {
LazyManSingleton instance = LazyManSingleton.getInstance();
System.out.println("instance1 " instance);
}).start();
new Thread(() -> {
LazyManSingleton instance = LazyManSingleton.getInstance();
System.out.println("instance2 " instance);
}).start();
}
}
输出：
instance2 designpattern.single.LazyMan.LazyManSingleton@1025efd2
instance1 designpattern.single.LazyMan.LazyManSingleton@22ff7883运行多次以后，我们发现创建了两个对象，那么如何避免这种情况呢，当然有方法，我们可以使用加锁的方式来实现线程安全问题，如下。
代码语言：javascript复制public class LazyManSingleton {
private static LazyManSingleton lazyManSingleton = null;
public synchronized static LazyManSingleton getInstance(){
if (lazyManSingleton == null){
lazyManSingleton = new LazyManSingleton();
}
return lazyManSingleton;
}
}我们使用了同步阻塞锁synchronized 锁来同步方法，这样，每个线程访问时都要等待当前线程访问完成后才能进行访问，那么其中就有一个问题，明明只需要一个线程创建对象后其他线程就能使用，而现在，明明对象已经创建完成了，只需要判断一下就返回对象，但是我一堆线程还阻塞在外面，只是为了一个判断，这是很不合理的，没事，我们继续改进。
三.双重校验锁（DCL）
懒汉式加锁可以实现线程安全，但是其效率很低，所以我们使用了双重锁校验，代码如下。
代码语言：javascript复制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的内部类会在外部类执行前先执行，这样我们就可以在内部类里面进行实例化，然后外部类获取实例，代码如下。
代码语言：javascript复制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 可以防止。
代码语言：javascript复制public enum EnumSingle {
INSTANCE;
public EnumSingle getInstance(){
return INSTANCE;
}
}public class Client {
public static void main(String[] args) {
new Thread(() -> {
EnumSingle instance = EnumSingle.INSTANCE.getInstance();
System.out.println(instance.hashCode());
}).start();
new Thread(() -> {
EnumSingle instance = EnumSingle.INSTANCE.getInstance();
System.out.println(instance.hashCode());
}).start();
}
}
输出：
1236783213
1236783213单例模式总结
在使用单例模式时要考虑是否存在线程安全和效率问题，选择合适的方式。
单例模式优点
保证内存中只创建一个实例，减少内存的开销，实现资源的复用。
单例模式的缺点
单例模式违背了开闭原则，并且没有抽象和接口，如果其发生变化，只能修改其内部代码。
今天的分享就到这里，感谢你的观看，我们下期见。
