单例模式的实现（5种）
常用:
饿汉式(线程安全，调用效率高，但是不能延时加载)
懒汉式（线程安全，调用效率不高，可以延时加载）
其他：
双重检测锁式（由于jvm底层内部模型原因，偶尔会出问题，不建立使用）
静态内部类式（线程安全，调用效率高，但是可以延时加载）
枚举单例（线程安全，调用效率高，不能延时加载）
饿汉式单例具体代码如下：
|
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
83
84
85
86
87
|
package com.lcx.mode; /** * * 饿汉式单例，不管以后用不用这个对象，我们一开始就创建这个对象的实例， * 需要的时候就返回已创建好的实例对象，所以比较饥饿，故此叫饿汉式单例。 * @author qq1013985957 * */public class SingletonHanger { private static final SingletonHanger instance = new SingletonHanger(); private SingletonHanger() { } public static SingletonHanger getInstance(){ return instance; } } /** * 懒汉汉式单例，在需要单例对象的时候，才创建唯一的单例对象，以后再次调用，返回的也是第一创建的单例对象 * 将静态成员初始化为null，在获取单例的时候才创建，故此叫懒汉式。 * @author qq1013985957 * */class SingletonLazy{ private static SingletonLazy instance = null; private SingletonLazy() { } /** * 此方法实现的单例，无法在多线程中使用，多线可以同时进入if方法，会导致生成多个单例对象。 * @return */ public static SingletonLazy getInstance1(){ if(instance==null){ instance = new SingletonLazy(); } return instance; } /** * 大家都会想到同步，可以同步方法实现多线程的单例 * 但是这种方法不可取，严重影响性能，因为每次去取单例都要检查方法，所以只能用同步代码块的方式实现同步。 * @return */ public static synchronized SingletonLazy getInstance2(){ if(instance==null){ instance = new SingletonLazy(); } return instance; } /** * 用同步代码块的方式，在判断单例是否存在的if方法里使用同步代码块，在同步代码块中再次检查是否单例已经生成， * 这也就是网上说的 双重检查加锁的方法 * @return */ public static synchronized SingletonLazy getInstance3(){ if(instance==null){ synchronized (SingletonLazy.class) { if(instance==null){ instance = new SingletonLazy(); } } } return instance; } } /** * * 使用枚举实现单例模式，也是Effective Java中推荐使用的方式 * 根据具体情况进行实例化，对枚举不熟悉的同学，可以参考我的博客 JAVA 枚举类的初步理解。 * 它的好处：更加简洁，无偿提供了序列化机制，绝对防止多次实例化，即使面对复杂的序列和反射攻击。 * @author qq1013985957 * */enum SingletionEnum{ SingletionEnum("单例的枚举方式"); private String str ; private SingletionEnum(String str){ this.setStr(str); } public String getStr() { return str; } public void setStr(String str) { this.str = str; } } |
以上的单例模式就不测试，大家可以去测试，判断对象的hashcode是否一致来判断是否为同一个对象。
恶汉式、懒汉式的方式还不能防止反射来实现多个实例，通过反射的方式，设置ACcessible.setAccessible方法可以调用私有的构造器，可以修改构造器，让它在被要求创建第二个实例的时候抛出异常。
其实这样还不能保证单例，当序列化后，反序列化是还可以创建一个新的实例，在单例类中添加readResolve()方法进行防止。
懒汉汉式单例代码如下：
|
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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
|
package com.lcx.mode; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; /** * 懒汉汉式单例，在需要单例对象的时候，才创建唯一的单例对象，以后再次调用，返回的也是第一创建的单例对象 * 将静态成员初始化为null，在获取单例的时候才创建，故此叫懒汉式。 * @author qq1013985957 * */public class Singleton implements Serializable{ /** * */ private static final long serialVersionUID = -5271537207137321645L; private static Singleton instance = null; private static int i = 1; private Singleton() { /** * 防止反射攻击，只运行调用一次构造器，第二次抛异常 */ if(i==1){ i++; }else{ throw new RuntimeException("只能调用一次构造函数"); } System.out.println("调用Singleton的私有构造器"); } /** * 用同步代码块的方式，在判断单例是否存在的if方法里使用同步代码块，在同步代码块中再次检查是否单例已经生成， * 这也就是网上说的 双重检查加锁的方法 * @return */ public static synchronized Singleton getInstance(){ if(instance==null){ synchronized (Singleton.class) { if(instance==null){ instance = new Singleton(); } } } return instance; } /** * * 防止反序列生成新的单例对象，这是effective Java 一书中说的用此方法可以防止，具体细节我也不明白 * @return */ private Object readResolve(){ return instance; } public static void main(String[] args) throws Exception { test1(); test2(); } /** * 测试 反序列 仍然为单例模式 * @throws Exception */ public static void test2() throws Exception{ Singleton s = Singleton.getInstance(); ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(new File("E:\\Singleton.txt"))); objectOutputStream.writeObject(s); ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(new File("E:\\Singleton.txt"))); Object readObject = objectInputStream.readObject(); Singleton s1 = (Singleton)readObject; System.out.println("s.hashCode():"+s.hashCode()+",s1.hashCode():"+s1.hashCode()); objectOutputStream.flush(); objectOutputStream.close(); objectInputStream.close(); } /** * 测试反射攻击 * @throws Exception */ public static void test1(){ Singleton s = Singleton.getInstance(); Class c = Singleton.class; Constructor privateConstructor; try { privateConstructor = c.getDeclaredConstructor(); privateConstructor.setAccessible(true); privateConstructor.newInstance(); } catch (Exception e) { e.printStackTrace(); } } } |
验证反射攻击结果：
如果不添加readResolve方法的结果：
添加readResolve方法的结果：
感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！
