设计模式之 -- 单例模式

需要最终结果的直接翻到最后

目的

单例模式的存在意义是保证每次取的对象都是同一个对象

public class SingleClass {
    private static SingleClass sInstance;
    
    private SingleClass() {
        
    }
    
    static SingleClass newInstance() {
        if (sInstance == null) {
            sInstance = new SingleClass();
        }
        return sInstance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

以上为获取一个类的过程，可是会出现线程问题，不能保证每次拿到的对象都是同一个，最简单的方式是给 newInstance 方法加锁

public class SingleClass {
    private static SingleClass sInstance;
    
    private SingleClass() {
        
    }
    
    static synchronized SingleClass newInstance() {
        if (sInstance == null) {
            sInstance = new SingleClass();
        }
        return sInstance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

synchronized 是一个很重的操作，他是耗时的，所以说这样写是性能浪费的，因为每次调用都加上锁，从而导致性能浪费

我们只是第一次创建对象的时候有可能出问题，之后每次都是直接返回了，并不需要每次都上锁

按照以上思路，我们只把创建对象的过程保护起来就好

public class SingleClass {
    private static SingleClass sInstance;
    
    private SingleClass() {
        
    }
    
    static SingleClass newInstance() {
        if (sInstance == null) {
            synchronized (SingleClass.class) {
                sInstance = new SingleClass();
            }
        }
        return sInstance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

这样还是有问题，现在保护的是 sInstance = new SingleClass(); 而不是 sInstance，假设现在有两个线程同时执行到
if (sInstance == null) {
这样线程1会上锁，去执行 sInstance = new SingleClass(); 而线程2，会等待线程1将锁释放，然后线程2再去创建一遍对象，这样就又出现了无法保证返回的是同一个对象的问题

所以，在我们创建对象的时候再次判一次空，用来拦截第二个线程，只要有一个线程执行就够了。

public class SingleClass {
    private static SingleClass sInstance;
    
    private SingleClass() {
        
    }
    
    static SingleClass newInstance() {
        if (sInstance == null) {
            synchronized (SingleClass.class) {
                if (sInstance == null) {
                    sInstance = new SingleClass();
                }
            }
        }
        return sInstance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

目前来看已经基本没有问题，但是还是有极端的情况，假如说两个线程，第一个线程执行到了 sInstance = new SingleClass(); 但是 new SingleClass(); 也是一个复杂的过程，可能还没有完全创建出来，但是 jvm 已经将这个对象标记为可用了，这时候第二个线程走到了最外层的判空，发现已经不为空了，直接返回，但是由于对象没有创建完成，第二个线程拿到的就是一个错误的或者说是不可用的对象，所以说我们需要给 sInstance 变量加上 volatile 关键字修饰

关于 volatile，我有专门的文章介绍，点此查看

public class SingleClass {
    private static volatile SingleClass sInstance;
    
    private SingleClass() {
        
    }
    
    static SingleClass newInstance() {
        if (sInstance == null) {
            synchronized (SingleClass.class) {
                if (sInstance == null) {
                //  假如 sInstance = new SingleClass(“aaa”);，有一个 aaa 覆盖默认值的过程
                    sInstance = new SingleClass();
                }
            }
        }
        return sInstance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

以上为最终的写法，有人说这种还不够安全，在老版本的 Java 中这样可能还会有一丝丝问题，但是在新版本中已经足够安全了。