Java单例模式及开发应用场景

       所谓单例，指的就是单实例，有且仅有一个类实例，这个单例不应该由人来控制，而应该由代码来限制，强制单例。

　　单例有其独有的使用场景，一般是对于那些业务逻辑上限定不能多例只能单例的情况，例如：类似于计数器之类的存在，一般都需要使用一个实例来进行记录，若多例计数则会不准确。

　　其实单例就是那些很明显的使用场合，没有之前学习的那些模式所使用的复杂场景，只要你需要使用单例，那你就使用单例，简单易理解。

1、常见的单例模式有两种创建方式：所谓饿懒汉式与饿汉式

（1）懒汉式

　　何为懒？顾名思义，就是不做事，这里也是同义，懒汉式就是不在系统加载时就创建类的单例，而是在第一次使用实例的时候再创建。

详见下方代码示例：

 1 public class LHanDanli {
 2     //定义一个私有类变量来存放单例，私有的目的是指外部无法直接获取这个变量，而要使用提供的公共方法来获取
 3     private static LHanDanli dl = null;
 4     //定义私有构造器，表示只在类内部使用，亦指单例的实例只能在单例类内部创建
 5     private LHanDanli(){}
 6     //定义一个公共的公开的方法来返回该类的实例，由于是懒汉式，需要在第一次使用时生成实例，所以为了线程安全，使用synchronized关键字来确保只会生成单例
 7     public static synchronized LHanDanli getInstance(){
 8         if(dl == null){
 9             dl = new LHanDanli();
10         }
11         return dl;
12     }
13 }

（2）饿汉式

　　又何为饿？饿者，饥不择食；但凡有食，必急食之。此处同义：在加载类的时候就会创建类的单例，并保存在类中。

详见下方代码示例：

 1 public class EHanDanli {
 2     //此处定义类变量实例并直接实例化，在类加载的时候就完成了实例化并保存在类中
 3     private static EHanDanli dl = new EHanDanli();
 4     //定义无参构造器，用于单例实例
 5     private EHanDanli(){}
 6     //定义公开方法，返回已创建的单例
 7     public static EHanDanli getInstance(){
 8         return dl;
 9     }
10 }

2、双重加锁机制

　　何为双重加锁机制？

　　在懒汉式实现单例模式的代码中，有使用synchronized关键字来同步获取实例，保证单例的唯一性，但是上面的代码在每一次执行时都要进行同步和判断，无疑会拖慢速度，使用双重加锁机制正好可以解决这个问题：

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

　　看了上面的代码，有没有感觉很无语，双重加锁难道不是需要两个synchronized进行加锁的吗？

　　......

　　其实不然，这里的双重指的的双重判断，而加锁单指那个synchronized，为什么要进行双重判断，其实很简单，第一重判断，如果单例已经存在，那么就不再需要进行同步操作，而是直接返回这个实例，如果没有创建，才会进入同步块，同步块的目的与之前相同，目的是为了防止有两个调用同时进行时，导致生成多个实例，有了同步块，每次只能有一个线程调用能访问同步块内容，当第一个抢到锁的调用获取了实例之后，这个实例就会被创建，之后的所有调用都不会进入同步块，直接在第一重判断就返回了单例。至于第二个判断，个人感觉有点查遗补漏的意味在内（期待高人高见）。

　　不论如何，使用了双重加锁机制后，程序的执行速度有了显著提升，不必每次都同步加锁。

　　其实我最在意的是volatile的使用，volatile关键字的含义是：被其所修饰的变量的值不会被本地线程缓存，所有对该变量的读写都是直接操作共享内存来实现，从而确保多个线程能正确的处理该变量。该关键字可能会屏蔽掉虚拟机中的一些代码优化，所以其运行效率可能不是很高，所以，一般情况下，并不建议使用双重加锁机制，酌情使用才是正理！

3、类级内部类方式

　　饿汉式会占用较多的空间，因为其在类加载时就会完成实例化，而懒汉式又存在执行速率慢的情况，双重加锁机制呢？又有执行效率差的毛病，有没有一种完美的方式可以规避这些毛病呢？

　　貌似有的，就是使用类级内部类结合多线程默认同步锁，同时实现延迟加载和线程安全。

1 public class ClassInnerClassDanli {
2     public static class DanliHolder{
3         private static ClassInnerClassDanli dl = new ClassInnerClassDanli();
4     }
5     private ClassInnerClassDanli(){}
6     public static ClassInnerClassDanli getInstance(){
7         return DanliHolder.dl;
8     }
9 }

　　如上代码，所谓类级内部类，就是静态内部类，这种内部类与其外部类之间并没有从属关系，加载外部类的时候，并不会同时加载其静态内部类，只有在发生调用的时候才会进行加载，加载的时候就会创建单例实例并返回，有效实现了懒加载（延迟加载），至于同步问题，我们采用和饿汉式同样的静态初始化器的方式，借助JVM来实现线程安全。

　　其实使用静态初始化器的方式会在类加载时创建类的实例，但是我们将实例的创建显式放置在静态内部类中，它会导致在外部类加载时不进行实例创建，这样就能实现我们的双重目的：延迟加载和线程安全。

4.常见应用场景spring中的bean默认是单例模式

一、单例模式：在spring中其实是scope(作用范围)参数的缺省设定值

每个bean定义只生成一个对象实例,每次getBean请求获得的都是此实例
单例模式分为饿汉模式和懒汉模式，

饿汉模式	spring singleton的缺省是饿汉模式:启动容器时(即实例化容器时),为所有spring配置文件中定义的bean都生成一个实例
懒汉模式	在第一个请求时才生成一个实例,以后的请求都调用这个实例 spring singleton设置为懒汉模式: <beans default-lazy-init="true">

二、另一种和singleton对应的scope值---prototype多实例模式
调用getBean时,就new一个新实例
singleton和prototype的比较

singleton：

xml配置文件: <bean id="dvdTypeDAO" class="com.terana.hibernate.impl.DvdTypeDAOImpl" />

测试代码:         ctx = new ClassPathXmlApplicationContext("spring-hibernate-mysql.xml");         DvdTypeDAO tDao1 = (DvdTypeDAO)ctx.getBean("dvdTypeDAO");         DvdTypeDAO tDao2 = (DvdTypeDAO)ctx.getBean("dvdTypeDAO");

运行:         true com.terana.hibernate.impl.DvdTypeDAOImpl@15b0333 com.terana.hibernate.impl.DvdTypeDAOImpl@15b0333 说明前后两次getBean()获得的是同一实例,说明spring缺省是单例

prototype：

<bean id="dvdTypeDAO" class="com.terana.hibernate.impl.DvdTypeDAOImpl" scope="prototype" />

执行同样的测试代码

运行: false com.terana.hibernate.impl.DvdTypeDAOImpl@afae4a com.terana.hibernate.impl.DvdTypeDAOImpl@1db9852 说明scope="prototype"后,每次getBean()的都是不同的新实例