单例模式

懒汉式

public class LazySingleton{
    private LazySingleton instance;
    private LazySingleton{}//构造方法私有化
    public static LazySingleton getInstance{
        if(instance == null){
            instance = new LazySingleton();
        }
    return instance;
    }
}

之所以称之为“懒汉式”，是因为在需要该实例的时候才会去进行创建的操作。对于多线程开发，上面的单例模式就不能够保证该类对象是单例了，因为多线程可能会同时进入if语句内，从而都会去创建这个实例。

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

我们通过给getInstance方法添加synchronized关键字(也就是加锁)，保证该方法一次只能被一个线程调用，从而避免了上述的多线程破坏单例的情况。但是这个方法也存在缺点，就是当instance已经被初始化后再调用时每次都需要去做加锁的操作，非常影响效率。

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

我们直接将锁从方法挪到实例化对象中去了，这样的话当instance不等于空的时候不用处理锁，直接进行返回。但是这种写法仍然会有问题，当多个线程同时进入if语句时，都会排队获取锁并进行实例化对象，从而又破坏了单例模式。那我们应该怎么做呢？

public class LazySingleton{
    private LazySingleton instance;
    private LazySingleton(){};
    public static LazySingleton getInstance(){
        if(instance == null){ // 注释1
            synchronized(LazySingleton.class){
                if（instance == null){
                    instance = new LazySingleton();//注释2
                }
            }
        }
    return instance;
    }
}

我们可以在实例化之前再做一次判断，这样第一次获得所的线程实例化之后，后面获得锁的线程发现instance不为空，直接返回对象。但是这个方式仍然存在弊端，有可能会造成该对象不为空，但是不能被使用的情况。原因主要是因为实例化对象的时候会有以下三个步骤：

  1. 在堆内存中开辟空间；
  2. 初始化对象；
  3. 将该对象指向对应的引用，引用赋值

而这3个步骤的顺序不是固定的，有可能是1-2-3，也有可能是1-3-2，我们称之为指令重排。那试想一下，第一个线程获得锁后，实例化对象的顺序为1-3-2，当刚执行完3还没有来得及执行2的时候，第二个线程执行第一个if语句，会发现instance此时不为空直接返回。但是这时instance还没有被初始化，所以用instance进行操作就会出现问题。那该如何解决呢，答案就是添加volatile关键字禁止这种指令重排，代码如下：

public class LazySingleton{
    private volatile LazySingleton instance;
    private LazySingleton(){};
    public static LazySingleton getInstance(){
        if(instance == null){ // 注释1
            synchronized(LazySingleton.class){
                if（instance == null){
                    instance = new LazySingleton();//注释2
                }
            }
        }
    return instance;
    }
}

饿汉式

public class HungrySingleton{
    private static HungrySingleton instance = new HungrySingleton{};
    private HungrySingleton(){}
    public static HungrySingleton getInstance(){
        return instance;
    }
}

当调用HungrySingleton类的getInstance方法时，JVM将HungrySingleton类加载到内存中，通过类加载机制确保instance的唯一性。但是饿汉式存在一个问题，就是当类一旦被加载，instance实例就会被创建，会造成不必要的内存开销。

静态内部类

public class InnerClassSingleton{
    private static class InnerClassHolder{
        private static InnerClassSingleton instance = new InnerClassSingleton();
    }
    private InnerClassSingleton(){}
    public static InnerClassSingleton getInstance(){
        return InnerClassHolder.instance;
    }
}

静态内部类的这个方式相当于是结合了懒汉式和饿汉式两者的优点。通过饿汉式一样的类加载机制实现对象的唯一性，程序只有在调用getInstance方法时才会去加载InnerClassHolder类从而创建实例，避免加载InnerClassSingleton类时就创建对象，造成不必要的内存开销。

反射攻击

上面的饿汉式和静态内部类实现的单例模式碰到反射机制就变得无效了，具体代码如下：

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Test1 {

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class objClass = InnerClassSingleton.class;
        //获取类的构造器
        Constructor constructor = objClass.getDeclaredConstructor();
        //把构造器私有权限放开
        constructor.setAccessible(true);
        //正常的获取实例方式
        InnerClassSingleton staticInnerClass = InnerClassSingleton.getInstance();
        //反射创建实例
        InnerClassSingleton newStaticInnerClass = (InnerClassSingleton) constructor.newInstance();

        System.out.println(staticInnerClass);
        System.out.println(newStaticInnerClass);
        System.out.println(staticInnerClass == newStaticInnerClass);

    }

}

上面的结果返回的是false，说明出现了两个不同的实例，这就违反了我们的单例原则，不能保证只有一个实例了。那如何解决呢？

public class InnerClassSingleton{
    private static class InnerClassHolder{
        private static InnerClassSingleton instance = new InnerClassSingleton();
    }
    private InnerClassSingleton(){
    if(InnerClassHolder.instance != null){
      throw IllegalStateException();//在这里判断instance是否为空，不为空直接抛出异常
    }  
  }
  
    public static InnerClassSingleton getInstance(){
        return InnerClassHolder.instance;
    }
}

对于通过类加载时创建对象实例的这种单例模式，静态内部类、饿汉式，可以通过上面的方式来防止反射攻击。反之如果不是通过类加载时创建实例的方式就没有效果了。举个例子：

public class LazySingleton{
    private volatile LazySingleton instance;
    private LazySingleton(){
    if(instance != null){
      throw IllegalStateException();
    }  
  };
    public static LazySingleton getInstance(){
        if(instance == null){ // 注释1
            synchronized(LazySingleton.class){
                if（instance == null){
                    instance = new LazySingleton();//注释2
                }
            }
        }
    return instance;
    }
}

其实很好理解了，假设我们先通过反射创建对象，走到构造方法的时候instance对象为null，因此会正常创建对象并不会抛出异常。然后通过调用getInstance方法时，instance会重新实例化一次，从而就出现了两个不同的实例了。

其中对象的序列化也能够破坏单例模式，具体代码如下：

public class SerSingleton implements Serializable {
 2     private volatile static SerSingleton uniqueInstance;
 3     private  String content;
 4     public String getContent() {
 5         return content;
 6     }
 7 
 8     public void setContent(String content) {
 9         this.content = content;
10     }
11     private SerSingleton() {
12     }
13 
14     public static SerSingleton getInstance() {
15         if (uniqueInstance == null) {
16             synchronized (SerSingleton.class) {
17                 if (uniqueInstance == null) {
18                     uniqueInstance = new SerSingleton();
19                 }
20             }
21         }
22         return uniqueInstance;
23     }
24 
25     
26     public static void main(String[] args) throws IOException, ClassNotFoundException {
27         SerSingleton s = SerSingleton.getInstance();
28         s.setContent("单例序列化");
29         System.out.println("序列化前读取其中的内容："+s.getContent());
30         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("SerSingleton.obj"));
31         oos.writeObject(s);
32         oos.flush();
33         oos.close();
34 
35         FileInputStream fis = new FileInputStream("SerSingleton.obj");
36         ObjectInputStream ois = new ObjectInputStream(fis);
37         SerSingleton s1 = (SerSingleton)ois.readObject();
38         ois.close();
39         System.out.println(s+"\n"+s1);
40         System.out.println("序列化后读取其中的内容："+s1.getContent());
41         System.out.println("序列化前后两个是否同一个："+(s==s1));
42     }
43     
44 }

得到的结果为false，是两个不同的实例，因此通过序列化对象的方式会破坏单例模式。那有什么办法可以即保证单例、避免反射攻击又能避免序列化呢？ 答案就是枚举了，代码如下：

public enum  SerEnumSingleton implements Serializable {
 2     INSTANCE;
 3     private  String content;
 4     public String getContent() {
 5         return content;
 6     }
 7     public void setContent(String content) {
 8         this.content = content;
 9     }
10     private SerEnumSingleton() {
11     }
12 
13     public static void main(String[] args) throws IOException, ClassNotFoundException {
14         SerEnumSingleton s = SerEnumSingleton.INSTANCE;
15         s.setContent("枚举单例序列化");
16         System.out.println("枚举序列化前读取其中的内容："+s.getContent());
17         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("SerEnumSingleton.obj"));
18         oos.writeObject(s);
19         oos.flush();
20         oos.close();
21 
22         FileInputStream fis = new FileInputStream("SerEnumSingleton.obj");
23         ObjectInputStream ois = new ObjectInputStream(fis);
24         SerEnumSingleton s1 = (SerEnumSingleton)ois.readObject();
25         ois.close();
26         System.out.println(s+"\n"+s1);
27         System.out.println("枚举序列化后读取其中的内容："+s1.getContent());
28         System.out.println("枚举序列化前后两个是否同一个："+(s==s1));
29     }
30 }

至此，我们常见的单例模式就说完了，包括饿汉式、懒汉式、静态内部类和枚举4种方式。谢谢大家的支持！！！

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 202,056评论 5赞 474
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 84,842评论 2赞 378
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 148,938评论 0赞 335
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,296评论 1赞 272
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,292评论 5赞 363
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,413评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,824评论 3赞 393
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,493评论 0赞 256
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,686评论 1赞 295
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,502评论 2赞 318
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,553评论 1赞 329
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,281评论 4赞 318
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,820评论 3赞 305
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,873评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,109评论 1赞 258
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 42,699评论 2赞 348
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,257评论 2赞 341