设计模式-单例模式

http://ov1nop9io.bkt.clouddn.com/db54db2f-82b2-4222-8d63-e49a8a7fc966.png

  • 单例模式确保一个类只有一个实例，并提供一个全局访问点。主要解决一个全局使用的类频繁地创建与销毁

  • 应用场景：线程池、缓存、对话框、处理器偏好设置和注册表的对象等等

  • 确保一个类只有一个实例，并提供了一个全局访问点

  • 类图：

  • 使用一个私有构造函数、一个私有静态变量以及一个公有静态函数来实现。

  • 私有构造函数保证了不能通过构造函数来创建对象实例，

  • 只能通过公有静态函数返回唯一的私有静态变量

懒汉式-线程不安全

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/**
 * 懒汉式-线程不安全，实例在第一次使用时创建
 * 私有静态变量 uniqueInstance 被延迟实例化，
 * 这样做的好处是，如果没有用到该类，那么就不会实例化 uniqueInstance，
 * 从而节约资源。
 这个实现在多线程环境下是不安全的，
 如果多个线程能够同时进入 if(uniqueInstance == null) ，
 那么就会多次实例化 uniqueInstance。
 */
public class Singleton {
    // 利用一个静态变量来记录Singleton的唯一实例。
    private static Singleton uniqueInstance;

    // 把构造器声明为私有的，只有Singleton类内才可以调用构造器。
    private Singleton() {
    }

    public static Singleton getUniqueInstance() {
        if (uniqueInstance == null) {
            // 如果uniqueInstance是空的，我们就利用私有的构造器产生一个Singleton实例并
            // 把它赋值给uniqueInstance静态变量中。请注意，如果我们不需要这个实例，它就
            // 永远不会产生。这就是“延迟实例化”
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }
}


懒汉式-线程安全

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/**
 * 懒汉式-线程安全
 * 假如有两个线程同时调用Singleton.getInstance()，
 * 而这时uniqueInstance还没有初始化，
 * 那么有可能会出现调用Singleton.getInstance()方法返回不同的实例
 *
 * 只需要对 getUniqueInstance() 方法加锁，
 * 那么在一个时间点只能有一个线程能够进入该方法，
 * 从而避免了对 uniqueInstance 进行多次实例化的问题。
 * 但是这样有一个问题，就是当一个线程进入该方法之后，
 * 其它线程试图进入该方法都必须等待，因此性能上有一定的损耗
 */
public class Singleton2 {
    private static Singleton2 uniqueInstance;

    private Singleton2() {

    }

    // 通过增加synchronized关键字到getInstance()方法中，我们
    // 迫使每个线程在进入这个方法之前，要先等候别的线程离开该方法。
    // 也就是说，不会有两个线程可以同时进入这个方法。
    public static synchronized Singleton2 getUniqueInstance() {
        if (uniqueInstance == null) {
            uniqueInstance = new Singleton2();
        }
        return uniqueInstance;
    }
}

饿汉式-线程安全

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/**
 * 饿汉式-线程安全，实例在类装载时创建
 * 线程不安全问题主要是由于 uniqueInstance 被实例化了多次，
 * 如果 uniqueInstance 采用直接实例化的话，
 * 就不会被实例化多次，也就不会产生线程不安全问题。
 * 但是直接实例化的方式也丢失了延迟实例化带来的节约资源的优势
 *
 * 我们依赖JVM在加载这个类时马上创建此唯一的单件实例。
 * JVM保证在任何线程访问uniqueInstance静态变量之前，一定先创建此实例。
 */
public class Singleton3 {
  
    // 由于不能使用构造方法创建实例，所以在类内部创建该类的唯一实例
  	// 在静态初始化器中创建单件。这段代码保证了线程安全
  	// 使用static修饰singleton在外界可以通过类名调用该实例 类名.成员名
  	// private封装实例 ，需要用get方法实现对外界的开放
    private static Singleton3 uniqueInstance = new Singleton3();

  	// 使用private将构造方法私有化，以防止外界通过构造方法创建多个实例
    private Singleton3(){

    }

    public static Singleton3 getUniqueInstance(){
        return uniqueInstance;
    }
}

双重校验锁-线程安全

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
/**
 * 双重校验锁-线程安全
 * uniqueInstance 只需要被实例化一次，之后就可以直接使用了。
 * 加锁操作只需要对实例化那部分的代码进行。也就是说，
 * 只有当 uniqueInstance 没有被实例化时，才需要进行加锁。
 双重校验锁先判断 uniqueInstance 是否已经被初始化了，如果没有被实例化，
 那么才对实例化语句进行加锁。
 这个做法可以帮你大大地减少getInstance()的时间耗费
 */
public class Singleton4 {
    // volatile关键词确保，当uniqueInstance变量被初始化成Singleton实例时，
	// 
    // 多个线程正确地处理uniqueInstance变量
    private volatile static Singleton4 uniqueInstance;
    private Singleton4(){

    }
    public static synchronized Singleton4 getUniqueInstance(){
        // 检查实例，如果不存在，就进入同步区块。
        if (uniqueInstance == null){
            // 注意，只有第一次才彻底执行这里的代码
            synchronized (Singleton4.class){
                // 进入区块后，再检查一次。如果仍是null，才创建实例
                if (uniqueInstance == null){
                    uniqueInstance = new Singleton4();
                }
            }
        }
        return uniqueInstance;
    }
}

ps:

这段代码看起来有点复杂，注意其中有两次if(instance==null)的判断

  • 第一个 if(instance==null)，其实是为了解决代码二中的效率问题，只有instance为null的时候，才进入synchronized的代码段大大减少了几率。
  • 第二个if(instance==null)，则是跟代码二一样，是为了防止可能出现多个实例的情况。

这段代码看起来已经完美无瑕了。当然，只是『看起来』，还是有小概率出现问题的。想要充分理解需要先弄清楚以下几个概念：原子操作、指令重排。

原子操作：
简单来说，原子操作（atomic）就是不可分割的操作，在计算机中，就是指不会因为线程调度被打断的操作。比如，简单的赋值是一个原子操作：

m = 6; // 这是个原子操作

假如m原先的值为0，那么对于这个操作，要么执行成功m变成了6，要么是没执行 m还是0，而不会出现诸如m=3这种中间态——即使是在并发的线程中。

但是，声明并赋值就不是一个原子操作：

int n=6;//这不是一个原子操作

对于这个语句，至少有两个操作：①声明一个变量n ②给n赋值为6——这样就会有一个中间状态：变量n已经被声明了但是还没有被赋值的状态。这样，在多线程中，由于线程执行顺序的不确定性，如果两个线程都使用m，就可能会导致不稳定的结果出现。

指令重排：
简单来说，就是计算机为了提高执行效率，会做的一些优化，在不影响最终结果的情况下，可能会对一些语句的执行顺序进行调整。比如，这一段代码：

int a ; // 语句1 a = 8 ; // 语句2 int b = 9 ; // 语句3 int c = a + b ; // 语句4

正常来说，对于顺序结构，执行的顺序是自上到下，也即1234。但是，由于指令重排
的原因，因为不影响最终的结果，所以，实际执行的顺序可能会变成3124或者1324。

由于语句3和4没有原子性的问题，语句3和语句4也可能会拆分成原子操作，再重排。——也就是说，对于非原子性的操作，在不影响最终结果的情况下，其拆分成的原子操作可能会被重新排列执行顺序。

singleton = new Singleton()这句，这并非是一个原子操作，事实上在 JVM 中这句话大概做了下面 3 件事情。
　　1. 给 singleton 分配内存
　　2. 调用 Singleton 的构造函数来初始化成员变量，形成实例
　　3. 将singleton对象指向分配的内存空间（执行完这步 singleton才是非 null了）

在JVM的即时编译器中存在指令重排序的优化。
也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，被线程二抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 instance，然后使用，然后顺理成章地报错。
再稍微解释一下，就是说，由于有一个『instance已经不为null但是仍没有完成初始化』的中间状态，而这个时候，如果有其他线程刚好运行到第一层if (instance ==null)这里，这里读取到的instance已经不为null了，所以就直接把这个中间状态的instance拿去用了，就会产生问题。这里的关键在于线程T1对instance的写操作没有完成，线程T2就执行了读操作。

解决方案为：给instance的声明加上volatile关键字

volatile关键字的一个作用是禁止指令重排，把instance声明为volatile之后，对它的写操作就会有一个内存屏障，这样，在它的赋值完成之前，就不用会调用读操作。

注意：volatile阻止的不是singleton = new Singleton()这句话内部[1-2-3]的指令重排，而是保证了在一个写操作（[1-2-3]）完成之前，不会调用读操作（if (instance == null)）。

其它方法

静态内部类：

1
2
3
4
5
6
7
8
9
public class Singleton{
    private static class SingletonHolder{
        private static final Singleton INSTANCE = new Singleton();
    }
    private Singleton(){}
    public static Singleton getInstance(){
        return SingletonHolder.INSTANCE;
    }
}

这种写法的巧妙之处在于：对于内部类SingletonHolder，它是一个饿汉式的单例实现，在SingletonHolder初始化的时候会由ClassLoader来保证同步，使INSTANCE是一个真单例。

同时，由于SingletonHolder是一个内部类，只在外部类的Singleton的getInstance()中被使用，所以它被加载的时机也就是在getInstance()方法第一次被调用的时候。
它利用了ClassLoader来保证了同步，同时又能让开发者控制类加载的时机。从内部看是一个饿汉式的单例，但是从外部看来，又的确是懒汉式的实现

枚举：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/**
 * @Author: Usher
 * @Description:
 * 枚举实现单例
 */
public class SingletonEnum {

    private SingletonEnum() {
    }

    public static SingletonEnum getInstance(){
        return Singleton.INSTANCE.getSingletonEnum();
    }

    
    private enum Singleton{
        INSTANCE;

        private SingletonEnum singletonEnum;
        // JVM保证这个方法绝对只调用一次
        Singleton(){
            singletonEnum = new SingletonEnum();
        }

        public SingletonEnum getSingletonEnum() {
            return singletonEnum;
        }
    }
}

因为自动序列化机制，保证了线程的绝对安全。

这种写法在功能上与共有域方法相近，但是它更简洁，无偿地提供了序列化机制，绝对防止对此实例化，即使是在面对复杂的序列化或者反射攻击的时候。虽然这中方法还没有广泛采用，但是单元素的枚举类型已经成为实现Singleton的最佳方法。