Java设计模式学习01——单例模式

Java单例模式是一种常见且较为简单的设计模式。单例模式，顾名思义一个类仅能有一个实例，并且向整个系统提供这一个实例。 
单例模式的特点：

• 单例类仅能有一个实例。
• 单例类必须为自己创建实例。
• 单例类必须向外界提供获取实例的方法。 
  以下是几种实现方法

一、懒汉式单例（能够延时加载）

public class SingleTon {     private static SingleTon instance = null ;     private SingleTon(){        }     public static SingleTon getInstance(){         if(instance==null){             instance=new SingleTon();        }         return instance ;    }}   
1
2
3
4
5
6
7
8
9
10
11
12
1
2
3
4
5
6
7
8
9
10
11
12

通过是构造方法私有化使该类不能在外界实例化，只能通过public方法获取实例，从而保证实例唯一。 
但是以上的代码是线程不安全的，多线程并发的情况下，SingleTon可能产生多个实例，可以通过以下方法对getInstance方法进行改进从而保证懒汉式单例线程安全。

1.在getInstance()方法上加上同步

public class SingleTon {     private static SingleTon instance = null ;     private SingleTon(){    }     //方法同步，调用效率低！     public static synchronized SingleTon getInstance(){         if(instance==null){             instance=new SingleTon();        }         return instance ;    }}   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.静态内部类式

public class SingleTon {       private static class SingletonClassInstance {         private static final SingleTon instance=new  SingleTon();    }     private SingleTon(){        }     //方法没有同步，调用效率高！     public static SingleTon getInstance(){         return SingletonClassInstance.instance ;    }}   
1
2
3
4
5
6
7
8
9
10
11
12
1
2
3
4
5
6
7
8
9
10
11
12

3.双重校验锁式

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

二、饿汉式单例 （不能够延时加载）

public class SingleTon {     //类初始化时，立即加载这个对象,加载类时，天然的是线程安全的！     private static SingleTon instance=new SingleTon();     private SingleTon(){    }     //方法没有同步，调用效率高！     public static SingleTon getInstance(){         return instance ;    }}   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。

三、枚举式单例

public enum SingleTon {     //这个枚举元素，本身就是单例对象！     INSTANCE;     //添加自己需要的操作！     public void singletonOperation(){    }}   
1
2
3
4
5
6
7
8
9
10
11
1
2
3
4
5
6
7
8
9
10
11

枚举式单例是线程安全的，调用效率高，并且可以天然的防止反射和反序列化漏洞。

四、防止反射和反序列化

---

事实上，通过Java反射或反序列化能够获取构造方法为private的类实例，那么所有的单例都会失效。所以为了避免这种后果，需要采取相应措施。

/** *懒汉式单例模式(如何防止反射和反序列化漏洞) * */public class SingleTon implements Serializable {     //类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）。     private static SingleTon instance ;       private SingleTon(){  //私有化构造器         if(instance!=null){             throw new RuntimeException(); //防止反射        }    }     //方法同步，调用效率低！     public static synchronized SingleTon getInstance(){         if(instance==null){             instance=new SingleTon();        }         return instance ;    }     //反序列化时，如果定义了readResolve()则直接返回此方法指定的对象。而不需要单独再创建新对象！     private Object readResolve() throws ObjectStreamException {         return 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
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

五、如何选用单例模式实现方式

• 单例对象占用资源少，且不需要延时加载：枚举式 好于 饿汉式
• 单例对象占用资源大，且需要延时加载：静态内部类式 好于 一般懒汉式