单例 Singleton

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

public class Singleton {
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    private Singleton() {
    }

    public static final Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

 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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

/*
方式一: 饿汉式单例模式
缺点是它不是一种懒加载模式 (lazy initialization) ，单例会在加载类后一开始就被初始化，即使客户端没有调用 getInstance()方法。
饿汉式的创建方式在一些场景中将无法使用: 譬如 Singleton 实例的创建是依赖参数或者配置文件的，
在 getInstance() 之前必须调用某个方法设置参数给它，那样这种单例写法就无法使用了。
*/
 package org.qiujy.test;
public class Singleton1 {
//构造方式设为private,外部不能访问
 private Singleton1() {
 }
// 在自己内部定义自己的一个private实例,只供内部调用
 private static final Singleton1 instance = new Singleton1();
// 提供了一个供外部访问本class的静态方法,可以直接访问
 public static Singleton1 getInstance() {
 return instance;
 }
 }

//方式二: 懒汉式单例模式
package org.qiujy.test;

public class Singleton2 {
private static Singleton2 instance = null;

//这个synchronized很重要
 public static synchronized Singleton2 getInstance() {
// 第一次使用时生成实例
 if (instance == null){
 instance = new Singleton2();
 }

return instance;
 }
 }
 //------------------------------------------------------------------------------------//

//多线程2: 双重判断
public class Singleton { 
 private static volatile Singleton singleton; 
 private static Lock lock = new ReentrantLock(); 

 private Singleton(){}; 
 public static Singleton getInstance(){ 
 if(singleton == null){ 
 lock.lock(); 
 try { 
 if(singleton == null){ 
 singleton = new Singleton(); 
 } 
 } finally{ 
 lock.unlock(); 
 } 
 }
 return singleton; 
 } 
} 
/*
这里为什么用 volatile, 主要还是因为 singleton = new Singleton(); 并不是原子性的，它会分为3步: 

给 instance 分配内存
调用 Singleton 的构造函数来初始化成员变量
将instance对象指向分配的内存空间 (执行完这步 instance 就为非 null 了) 
但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，
最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，被线程二抢占了，
这时 instance 已经是非 null 了 (但却没有初始化) ，所以线程二会直接返回 instance，然后使用，然后顺理成章地报错。 
所以这里的 volatile 主要是用来做禁止指令重排序的。
*/

Google公司的工程师Bob Lee写的新的懒汉单例模式
public class Singleton {
static class SingletonHolder {
 static Singleton instance = new Singleton();
 }

public static Singleton getInstance() {
 return SingletonHolder.instance;
 }

}
//在加载singleton时并不加载它的内部类SingletonHolder，而在调用getInstance () 时调用SingletonHolder时才加载SingletonHolder，
//从而调用singleton的构造函数，实例化singleton，从而达到lazy loading的效果。