java单例模式（Singleton）的5种实现

admin

Singleton是一种创建型模式，指某个类采用Singleton模式，则在这个类被创建后，只可能产生一个实例供外部访问，并且提供一个全局的访问点

实现的方式有如下四种：

(1)线程安全，但效率比较低

1. <font color="#454545"><font face="Verdana,">/**  
   , U  z! }% U4 j  Q/ G0 w
2. *   
   
3. * 单例模式的实现：饿汉式,线程安全 但效率比较低  
   
4. */  
   
5. public class SingletonTest {   
   
6.   
   . o' \& D2 L' T5 r* d
7.     private SingletonTest() {   
   
8.     }   
   2 M" {$ Z) s7 ]3 b* W6 |
9.   
   
10.     private static final SingletonTest instance = new SingletonTest();   
    
11.   
    + I# Q; b: W7 S% d8 _1 |
12.     public static SingletonTest getInstancei() {   
    2 t; x0 U5 p/ s" q0 E; I: Z1 v
13.         return instance;   
    $ V. H0 k/ [- C" e6 ^3 d0 E; A) t
14.     }   
    
15.   
    % P0 @1 x: `& [/ R
16. }  </font></font>

复制代码

(2)非线程安全
7 y. a* w1 I3 {2 I7 i

1. <font color="#454545"><font face="Verdana,">/**  
   
2. * 单例模式的实现：饱汉式,非线程安全   
   0 z, g! u! P# s, {0 w. j2 x0 i/ ~
3. *   
   . H' A9 ]: T- _& q  [
4. */  
   
5. public class SingletonTest {   
     e1 z6 G9 F( I+ P! z: t
6.     private SingletonTest() {   
   6 G) t7 g1 N* k3 E: X3 g- x
7.     }   
   + @- a6 |1 Y7 g
8.   
   
9.     private static SingletonTest instance;   
   & q7 \/ W5 O  E5 [4 s5 p$ m* v! g
10.   
    
11.     public static SingletonTest getInstance() {   
    ! j" n3 f7 ^" \* q- `( m" r( E
12.         if (instance == null)   
    
13.             instance = new SingletonTest();   
    
14.         return instance;   
    & c* \) t% A" j
15.     }   
    
16. }</font></font>

复制代码

& I2 E5 G# v8 ^6 z- K3 @  D(3)线程安全，但效率比较低
, h4 t1 q4 m1 L, ^$ b

1. <font color="#454545"><font face="Verdana,">/**
   
2. * 线程安全，但是效率非常低
   1 g8 V/ x0 T7 C9 e; c( d4 d# \
3. * @author vanceinfo
   
4. *
   
5. */  
   / k( Z6 e+ T9 T
6. public class SingletonTest {  
   
7.     private SingletonTest() {  
   ' s8 a4 o9 r- J& b& P4 I
8.     }  
   ! D$ d2 M, H/ @% S+ `1 G& d) C( x1 h
9.   
   
10.     private static SingletonTest instance;  
    
11.   
    3 j) P8 h6 i2 O2 D' ^- r* E, s
12.     public static synchronized SingletonTest getInstance() {  
    
13.         if (instance == null)  
    
14.             instance = new SingletonTest();  
    0 z7 S* i( P8 r# z  ~
15.         return instance;  
    
16.     }  
    
17. }</font></font>

复制代码

(4)线程安全，并且效率高

1. <font color="#454545"><font face="Verdana,">/**  
   
2. * 线程安全  并且效率高  
   
3. *  
   5 N( [% s" U1 |8 K
4. */  
   0 v' {, m# a2 h' r) l
5. public class SingletonTest {   
   & l$ f! z: H- f) P, }0 k. }
6.     private static SingletonTest instance;   
   3 r) }9 i. ~, @$ {- f+ F0 ]% G% Q* H
7.   
   
8.     private SingletonTest() {   
   6 D0 B0 d- ]% x) r3 x0 u
9.     }   
   
10.   
    
11.     public static SingletonTest getIstance() {   
    9 j0 |- {; j/ ]7 I; ~7 R
12.         if (instance == null) {   
    
13.             synchronized (SingletonTest.class) {   
    & k% s+ Q' O! h& z, i
14.                 if (instance == null) {   
    
15.                     instance = new SingletonTest();   
    
16.                 }   
    ( ]: I, k/ p# S/ {( s3 c& n
17.             }   
    
18.         }   
    - j' H. Q9 b3 o7 @' b
19.         return instance;   
    $ G5 b$ J  F  e2 w
20.     }   
    & G# }, {7 K# ?! P# D* w, p
21. }</font></font>

复制代码

(5)Lazy initialization holder class模式

Lazy initialization holder class模式，这个模式综合使用了java的类级内部类和多线程缺省同步锁的知识，很巧妙的同时实现了延迟加载和线程安全。
, p" w4 W+ B( `1：先来看点相应的基础知识
* W" R9 Y1 g+ ^; Y3 J- z        先简单的看看类级内部类相关的知识。

• 什么是类级内部类？
  - d" O) T2 k! X5 W3 H    简单点说，类级内部类指的是：有static修饰的成员式内部类。如果没有static修饰的成员式内部类被称为对象级内部类。
• 类级内部类相当于其外部类的static成分，它的对象与外部类对象间不存在依赖关系，因此可直接创建。而对象级内部类的实例，是绑定在外部对象实例中的。
• 类级内部类中，可以定义静态的方法，在静态方法中只能够引用外部类中的静态成员方法或者成员变量。
• 类级内部类相当于其外部类的成员，只有在第一次被使用的时候才会被装载
  " M. p9 r" x( L3 j7 g& ~

        再来看看多线程缺省同步锁的知识。
. m# C# Z/ i" s, s8 W        大家都知道，在多线程开发中，为了解决并发问题，主要是通过使用synchronized来加互斥锁进行同步控制。但是在某些情况中，JVM已经隐含地为您执行了同步，这些情况下就不用自己再来进行同步控制了。这些情况包括：

• 由静态初始化器（在静态字段上或 static{} 块中的初始化器）初始化数据时
• 访问 final 字段时
• 在创建线程之前创建对象时
• 线程可以看见它将要处理的对象时
  

2：接下来看看这种解决方案的思路
        要想很简单的实现线程安全，可以采用静态初始化器的方式，它可以由JVM来保证线程安全性。比如前面的“饿汉式”实现方式，但是这样一来，不是会浪费一定的空间吗？因为这种实现方式，会在类装载的时候就初始化对象，不管你需不需要。
        如果现在有一种方法能够让类装载的时候不去初始化对象，那不就解决问题了？一种可行的方式就是采用类级内部类，在这个类级内部类里面去创建对象实例，这样一来，只要不使用到这个类级内部类，那就不会创建对象实例。从而同时实现延迟加载和线程安全。
3 Z0 v: N: T# m) B; ?8 Z" a        看看代码示例可能会更清晰，示例代码如下：

1. public class Singleton {
   0 J# c! c$ ?) [
2.         /**
   
3.          * 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例
   8 K3 t% _/ S8 K& ?+ ^  ^( S. a
4.          * 没有绑定关系，而且只有被调用到才会装载，从而实现了延迟加载
   1 k' R4 A2 d1 s
5.          */
   ( n' ?. k( [8 i) s5 I
6.         private static class SingletonHolder{
   
7.                 /**
   
8.                  * 静态初始化器，由JVM来保证线程安全
   7 d2 Y7 `4 O7 O7 F9 m. t2 e, w/ [
9.                  */
   & Q. H9 |7 [1 |" F# V7 [8 B+ J
10.                 private static Singleton instance = new Singleton();
    
11.         }
    
12.         /**
    ( d4 ]) Y: E2 C
13.          * 私有化构造方法
    + ]& {. Y4 t2 g' Q
14.          */
    
15.         private Singleton(){
    
16.         }
    $ \. A# T5 w4 z+ e+ f/ r3 v
17.         public static  Singleton getInstance(){
    ; _4 f: D2 ]" B( M# X' u0 Y
18.                 return SingletonHolder.instance;
    
19.         }
    7 Q1 K" e8 H7 ?" t+ p2 T5 S
20. }

复制代码

        当getInstance方法第一次被调用的时候，它第一次读取SingletonHolder.instance，导致SingletonHolder类得到初始化；而这个类在装载并被初始化的时候，会初始化它的静态域，从而创建Singleton的实例，由于是静态的域，因此只会被虚拟机在装载类的时候初始化一次，并由虚拟机来保证它的线程安全性。
        这个模式的优势在于，getInstance方法并没有被同步，并且只是执行一个域的访问，因此延迟初始化并没有增加任何访问成本。
2 f: }- b5 k: p, P" ^总结：
% {+ B) e% L: K' g
3 q7 ^5 z  D# G+ W9 p/ w

单例模式的优点：

单例模式（Singleton）会控制其实例对象的数量，从而确保访问对象的唯一性。

• 实例控制：单例模式防止其它对象对自己的实例化，确保所有的对象都访问一个实例。
• 伸缩性：因为由类自己来控制实例化进程，类就在改变实例化进程上有相应的伸缩性。
  5 w3 F6 J! m. q7 \6 \

! ?2 P: U2 K0 M% \1 ]; Z$ ?; d

单例模式的缺点：

• 系统开销。虽然这个系统开销看起来很小，但是每次引用这个类实例的时候都要进行实例是否存在的检查。这个问题可以通过静态实例来解决。
• 开发混淆。当使用一个单例模式的对象的时候（特别是定义在类库中的），开发人员必须要记住不能使用new关键字来实例化对象。因为开发者看不到在类库中的源代码，所以当他们发现不能实例化一个类的时候会很惊讶。
• 对象生命周期。单例模式没有提出对象的销毁。在提供内存管理的开发语言（比如，基于.NetFramework的语言）中，只有单例模式对象自己才能将对象实例销毁，因为只有它拥有对实例的引用。在各种开发语言中，比如C++，其它类可以销毁对象实例，但是这么做将导致单例类内部的指针指向不明。
  

( ~9 J) Z. V* @; ]$ b, J! p

单例适用性

使用Singleton模式有一个必要条件：在一个系统要求一个类只有一个实例时才应当使用单例模式。反之，如果一个类可以有几个实例共存，就不要使用单例模式。

不要使用单例模式存取全局变量。这违背了单例模式的用意，最好放到对应类的静态成员中。

不要将数据库连接做成单例，因为一个系统可能会与数据库有多个连接，并且在有连接池的情况下，应当尽可能及时释放连接。Singleton模式由于使用静态成员存储类实例，所以可能会造成资源无法及时释放，带来问题。

+ m# L+ `. S* A& h: Y+ B& H