java设计模式之单例模式（Singleton）

　　 利用元旦小假期，参考了几篇单例模式介绍的文章，然后自己下午对java设计模式中的单例模式做了一下简单的总结，主要是代码介绍。

      单例模式，在实际项目开发中运用广泛，比如数据库连接池，实际上，配置信息类、管理类、控制类、门面类、代理类通常被设计为单例类。像Java的Struts、spring框架，.Net的Spring.Net框架，以及PHP的Zend框架都大量使用单例模式。

　　那么，接下来，我将以下面5点来对单例模式作一下介绍：

　　1.单例模式的定义

　　2.单例模式的特点

　　3.为什么要使用单例模式？

　　4.单例模式的5种不同写法及其总结

　　5.拓展--如何防止Java反射机制对单例类的攻击？

1.单例模式的定义

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

核心知识点：
 （1）将采用单例模式的类的构造方法私有化（采用private修饰）；
 （2）在其内部产生该类的实例化对象，并将其封装成private static类型；
 （3）定义一个静态方法返回该类的实例。

2.单例模式的特点

　　- 单例类只能有一个实例；
　　- 单例类必须自己创建自己的唯一实例；
　　- 单例类必须给所有其他对象提供这一实例。

3.为什么要使用单例模式？

　　根据单例模式的定义和特点，我们会对单例模式有了初步认识，那么由特点出发，单例模式在项目中的作用就显而易见了。

　　（1）控制资源的使用，通过线程同步来控制资源的并发访问；
　　（2）控制实例产生的数量，到达节约资源的目的；
　　（3）作为通信媒介使用，也就是数据共享，他可以在不建立直接关联的条件下，让多个不相关的两个线程或者进程实现通信。
　　比如：
　　数据库连接池的设计一般采用单例模式，数据库连接是一种数据资源。项目中使用数据库连接池，主要是节省打开或者关闭数据库所引起的效率损耗。当然，使用数据库连接池可以屏蔽不同数据数据库之间的差异，实现系统对数据库的低度耦合，也可以被多个系统同时使用，具有高科复用性，还能方便对数据库连接的管理等。
　　实际上，配置信息类、管理类、控制类、门面类、代理类通常被设计为单例类。像Java的Struts、spring框架，.Net的Spring.Net框架，以及PHP的Zend框架都大量使用单例模式。

4.单例模式的5种不同写法及其总结

　　单例模式的实现常用的有5种，分别是：

　　(1).饿汉式;

　　(2).懒汉式(、加同步锁的懒汉式、加双重校验锁的懒汉式、防止指令重排优化的懒汉式);

　　(3).登记式单例模式;

　　(4)静态内部类单例模式;

　　(5).枚举类型的单例模式。

　　接下来，我就以代码为主来对各种实现方式介绍一下。

项目工程结构：如图中的红框1中所示。

(1).饿汉式

代码清单【1】

package com.lxf.singleton;

/**

 * 单例类--饿汉模式   线程安全
 * @author Administrator
 * 
 */
public class Singleton 
{
    private static final Singleton INSTANCE = new Singleton();
    
    private static boolean flag = true;
    private Singleton()
    {
    }
    
    public static Singleton newInstance()
    {
        return INSTANCE;
    }

}

　　从代码中，我们可以看到，该类的构造函数被定义为private，这样就保证了其他类不能实例化此类，然后该单例类提供了一个静态实例并返回给调用者（向外界提供了调用该类方法的实例）。饿汉模式在类加载的时候就对该实例进行创建，实例在整个程序周期都存在。

　　优点：只在类加载的时候创建一次，不会存在多个线程创建多个实例的情况，避免了多线程同步的问题，是线程安全的。
　 缺点：在整个程序周期中，即使这个单例没有被用到也会被加载，而且在类加载之后就被创建，内存就被浪费了。
　　使用场景：适合单例占用内存比较小，在初始化就被用到的情况。但是，如果单例占用的内存比较大，或者单例只是在某个场景下才会被使用到，使用该模式就不合适了，这时候就要考虑使用“懒汉模式”进行延迟加载。

(2).懒汉式(、加同步锁的懒汉式、加双重校验锁的懒汉式、防止指令重排优化的懒汉式)

2.1--懒汉式(、加同步锁的懒汉式

代码清单【2.1】

package com.lxf.singleton;

/**
 * 懒汉式单例模式   线程不安全
 * @author Administrator
 *
 */
public class Singleton2 
{
    private static Singleton2 instance = null;
    
    private Singleton2(){}

    /*
     * 1.未加同步锁
     */
    /*
    public static Singleton2 getInstance()
    {
        if(instance == null)
        {
            instance = new Singleton2();
        }
        return instance;
    }
    */
    
    /*
     * 2.加同步锁     线程安全
     * 上面的懒汉模式并没有考虑多线程的安全问题，在多性格线程可能并发调用它的getInsatance()方法，
     * 导致创建多个实例，因此需要加锁来解决线程同步问题。
     */
    public static synchronized Singleton2 getInstance()
    {
        if(instance == null)
        {
            instance = new Singleton2();
        }
        return instance;
    }

}

　　懒汉式单例模式是在需要的时候才去创建，如果调用该接口获取实例的时候，发现该实例不存在，就会被创建；如果发现该实例已经存在，就会返回之前已经创建出来的实例。

　　但是懒汉模式的单例设计，是线程不安全的，没有考虑线程安全问题。如果你的程序是多线程的，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程的运行结果一样的，而且其他的变量的值也和预期一样的，就是线程安全的。显然，懒汉式单例模式并不是线程安全的，在多线程并发环境下，可能会创建出来多个实例。

　　使用场景：适合在项目中使用单例类数量较少，而且占用资源比较多的项目，可以考虑使用懒汉式单例模式。

2.2--加双重校验锁的懒汉式、防止指令重排优化的懒汉式

代码清单【2.2】

package com.lxf.singleton;

/**
 * 双重校验锁     线程安全
 * @author Administrator
 * 
 */
public class Singleton3
{
    private static Singleton3 instance = null;
    //禁止指令重排优化
    //private static volatile Singleton3 instance = null;
    private Singleton3(){}
    
    public static Singleton3 getInstance()
    {
        if(null == instance)
        {
            synchronized (Singleton3.class)
            {
                if(null == instance)
                {
                    //双重校验
                    instance = new Singleton3();
                }
                
            }
        }
        return instance;
    }

}

　 　在加锁的懒汉模式中，看似解决了线程的并发安全问题，有实现了延迟加载，然而它存在着性能问题。synchronized修饰的同步方法比一般方法要慢很多，如果多次调用getInstance()，累积的性能损耗就比较大了。因此，我们这里就有了双重校验锁。在上面的双重校验锁代码中，由于单例对象只需要创建一次，如果后面再次调用getInstance()只需要直接返回单例对象。

     因此，大部分情况下，调用getInstance()都不会执行到同步代码块中的代码，从而提高了性能。

     不过，在这里要提到Java中的指令重排优化。指令重排优化：在不改变原语义的情况下，通过调整指令的执行顺序让程序运行的更快。

     由于指令重拍优化的存在，导致初始化Singleton3和将对象地址付给instance字段的顺序是不确定的。比如：在某个线程创建单例对象时，在构造方法被调用之前，就为该对象分配了内存空间并将对象的字段设置为默认值。此时就可以将分配的内存地址复制给instance字段了，然后该对象可能还没有初始化。若紧接着另外一个线程来调用getInstance,得到的是状态不确定的对象，程序就会出错。

　　以上就是双重校验锁会失效的原因。不过在JDK1.5及其以后的版本中，增加了volatile关键字。volatile的关键字的一个语义就是禁止指令重排优化，这样就保证了instance变量被赋值的时候已经是初始化的，避免了上面提到的状态不确定的问题。

3.登记式单例模式

代码清单【3】

package com.lxf.singleton;

import java.util.HashMap;
import java.util.Map;

/**
 * 登记式单例模式   线程安全
 * @author Administrator
 *就是将该类名进行登记，每次调用前查询，如果存在，则直接使用；不存在，则进行登记。
 *这里使用Map<String,Class>
 */
public class Singleton4 
{
    private static Map<String, Singleton4> map = new HashMap<String, Singleton4>();
    
    /*
     * 静态语句块，保证其中的内容在类加载的时候运行一次，并且只运行一次。
     */
    static 
    {
        Singleton4 singleton4 = new Singleton4();
        map.put(singleton4.getClass().getName(), singleton4);
    }
    
    //保护的默认构造子
    protected Singleton4 (){}
    //静态工厂方法，返回此类唯一的实例
    public static Singleton4 getInstance(String name)
    {
        if(null == name)
        {
            name = Singleton4.class.getName();
            System.out.println("name == null  --- > name == " + name);
        }
        if(null == map.get(name))
        {
            try {
                map.put(name, (Singleton4) Class.forName(name).newInstance());
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
        return map.get(name);
    }
    
}

 4.静态内部类单例模式;

代码清单【4】

package com.lxf.singleton;
/**
 * 静态内部类单例模式  线程安全
 * @author Administrator
 */
public class Singleton5 
{
    /*
     * 内部类，用于实现延迟机制
     * @author Administrator
     */
    private static class SingletonHolder
    {
        private static Singleton5 instance = new Singleton5();
    }
    //私有的构造方法，保证外部的类不能通过构造器来实例化
    private Singleton5(){}
    
    /*
     *获取单例对象的实例
     */
    public static Singleton5 getInstacne()
    {
        return SingletonHolder.instance;
    }

}

　　这种方式同样利用了类加载机制来保证只创建一个insatcne实例。因此不存在多线程并发的问题。它是在内部类里面去创建对象实例，这样的话，只要应用中不使用内部类，JVM就不会去加载这个单例类，
也就不会加载单例对象，从而实现了延迟加载。

 

5.枚举类型的单例模式。

代码清单【5】

package com.lxf.singleton;

/**
 * 我们要创建的单例类资源,比如：数据库连接，网络连接，线程池之类的。   
 * @author Administrator
 *
 */
class Resource
{
    public void doMethod()
    {
        System.out.println("枚举类型的单例类资源");
    }
}

/**
 * 枚举类型的单例模式   线程安全
 * 
 * 获取资源的方式，Singleton6.INSTANCE.getInstance();即可获得所要的实例。
 * @author Administrator
 *
 */


public enum Singleton6
{
    INSTANCE;
    
    private Resource instance;
    
    Singleton6()
    {
        instance = new Resource();
    }
    
    public Resource getInstance()
    {
        return instance;
    }
    
    
}

　　上面代码中，首先，在枚举中我们明确了构造方法限制为私有，在我们访问枚举实例时会执行构造方法，同时每个枚举实例都是static final类型的，也就表明只能被实例化一次。在调用构造方法时，我们的单例被实例化。也就是说，因为enum中的实例被保证只会被实例化一次，所以我们的INSTANCE也就会被实例化一次。
　　在之前介绍的实现单例的方式中都有共同的缺点：
(1).需要额外的工作来实现序列化，否则每次反序列化一个序列化的对象时都会创建一个新的实例；
(2).可以使用反射强行调用私有构造器(如果要避免这个情况，可以修改构造器，让它在创建第二个人实例的时候抛异常。)这个会在第5点中进行介绍
　　而使用枚举出了线程安全和防止反射调用构造器之外，还提供了自动序列化机制，防止反序列化的时候创建新的对象。

6.单例模式测试类   SingletonMain.java

 代码清单【6】

package com.lxf.singleton;

import org.junit.Test;

public class SingletonMain 
{
    /**
     *1. 饿汉模式单例测试
     */
    @Test
    public void testSingletonTest()
    {
        System.out.println("-------饿汉模式单例测试--------------");
        Singleton singleton = Singleton.newInstance();
        //singleton.about();
        Singleton singleton2 = Singleton.newInstance();
        //singleton2.about();
        
        if(singleton == singleton2)
        {
            System.out.println("1.singleton and singleton2 are same Object");
        }
        else
        {
            System.out.println("1.singleton and singleton2 aren't same Object");
        }
        System.out.println("---------------------------------------------");
    }
    
    /**
     *2. 懒汉式单例模式测试
     */
    @Test
    public void testSingleton2Test()
    {
        System.out.println("-------懒汉式单例模式测试--------------");
        Singleton2 singleton = Singleton2.getInstance();
        Singleton2 singleton2 = Singleton2.getInstance();
        
        if(singleton == singleton2)
        {
            System.out.println("2.singleton and singleton2 are same Object");
        }
        else
        {
            System.out.println("2.singleton and singleton2 aren't same Object");
        }
        System.out.println("---------------------------------------------");
    }
    
    /**
     * 3.双重校验锁单例模式测试
     */
    @Test
    public void testSingleton3()
    {
        System.out.println("-------双重校验锁单例模式测试--------------");
        Singleton3 singleton = Singleton3.getInstance();
        Singleton3 singleton2 = Singleton3.getInstance();
        
        if(singleton == singleton2)
        {
            System.out.println("3.singleton and singleton2 are same Object");
        }
        else
        {
            System.out.println("3.singleton and singleton2 aren't same Object");
        }
        System.out.println("---------------------------------------------");
    }
    
    /**
     * 4.登记式单例模式测试
     */
    @Test
    public void testSingleton4()
    {
        System.out.println("-------双重校验锁单例模式测试--------------");
        Singleton4 singleton = Singleton4.getInstance(Singleton4.class.getName());
        Singleton4 singleton2 = Singleton4.getInstance(Singleton4.class.getName());
        if(singleton == singleton2)
        {
            System.out.println("4.singleton and singleton2 are same Object");
        }
        else
        {
            System.out.println("4.singleton and singleton2 aren't same Object");
        }
        System.out.println("---------------------------------------------");
    }
    
    /**
     *5. 静态内部类单例模式测试
     */
    @Test
    public void testSingleton5()
    {
        System.out.println("-------静态内部类单例模式测试--------------");
        Singleton5 singleton = Singleton5.getInstacne();
        Singleton5 singleton2 = Singleton5.getInstacne();
        if(singleton == singleton2)
        {
            System.out.println("5.singleton and singleton2 are same Object");
        }
        else
        {
            System.out.println("5.singleton and singleton2 aren't same Object");
        }
        System.out.println("---------------------------------------------");
    }
    
    /**
     *6. 静态内部类单例模式测试
     */
    @Test
    public void testSingleton6()
    {
        System.out.println("-------枚举类型的单例类资源测试--------------");
        Resource singleton = Singleton6.INSTANCE.getInstance();
        Resource singleton2 = Singleton6.INSTANCE.getInstance();
        if(singleton == singleton2)
        {
            System.out.println("6.singleton and singleton2 are same Object");
        }
        else
        {
            System.out.println("6.singleton and singleton2 aren't same Object");
        }
        System.out.println("---------------------------------------------");
    }
    

}

运行结果：

5.拓展--如何防止Java反射机制对单例类的攻击？

　　上面介绍的除了最后一种枚举类型单例模式外，其余的写法都是基于一个条件：确保不会被反射机制调用私有的构造器。
那么如何防止Java反射机制对单例类的攻击呢？请参考下一篇随笔：《如何防止反射机制对单例类的攻击？》

 

 6.后期补充