六种常用的设计模式java实现（二）单例模式

上一节说完了工厂模式，那么，接下来给大家介绍下单例模式。单例模式想必大家应该都用得比较多，特别是在spring中，我们的java bean对象一般都是单例的。像项目中某些类只会被实例化一次或者只能实例化一次，我们都可以把这个类做成单例的。

一、基本概念

单例模式又叫做单态模式或者单件模式，保证一个类仅有 一个实例，并提供一个访问它的全局访问点。单例模式中的“单例”通常用来代表那些本质上 具有唯一性的系统组件（或者叫做资源）。比如文件系统、资源管理器等等。单例模式的目的就是要控制特定的类只产生一个对象，当然也允许在一定情况下灵活的 改变对象的个数。

二、分类及含义

单例模式的分类有好几种，把以下三种搞清楚就够了。
饿汉式：在第一次调用的时候实例化自己
懒汉式：在类初始化时，已经自行实例化，三种实现，synchronized、双重检查锁定、静态内部类
登记式：类似Spring里面的方法，将类名注册，下次从里面直接获取

三、代码实现

1、饿汉式
这里，我先直接贴出代码：

 package org.wuqiong.designpattern.singlepattern.hungryType;/** * ClassName:Singleton <br/> * Function: 单例模式-饿汉式. <br/> * Date:     2016年1月28日 上午11:57:28 <br/> * @author   qiyongkang * @version   * @since    JDK 1.6 * @see       */public class Singleton {    private static final Singleton instance = new Singleton();    private Singleton() {}    public static Singleton getInstance() {        return instance;    }}

可以看出，在此类被加载的时候，只被实例化一次。所以，这种方式，无论单线程还是多线程，都是比较安全的。唯一的缺点就是类一被加载就会实例化一次。
2、懒汉式
这里，懒汉式实现有三种方法：
1、使用synchronized同步方法

/** * ClassName:Singleton <br/> * Function: 单例模式-懒汉式，synchronized. <br/> * Date:     2016年1月28日 下午12:10:15 <br/> * @author   qiyongkang * @version   * @since    JDK 1.6 * @see  */public class Singleton {    private static Singleton instance = null;    private Singleton() {}    /**     *      * getInstance:在getInstance方法上加同步. <br/>     *     * @author qiyongkang     * @return     * @since JDK 1.6     */    public synchronized static Singleton getInstance() {        if (instance == null) {            instance = new Singleton();        }        return instance;    }}

这里，在方法前加synchronized关键字的目的大家应该清楚，就是防止多线程第一次实例化的时候出现问题。很显然，这种方式就没有在类加载的时候便实例化一次，而是在要用的时候才开始实例化。但是，由于加了同步，对性能方面也会有所影响。
2、双重检查锁定

package org.wuqiong.designpattern.singlepattern.lazyType;/** * ClassName:单例模式-懒汉式，双重检查锁定<br/> * Function: TODO ADD FUNCTION. <br/> * Date:     2016年1月29日 上午11:59:15 <br/> * @author   qiyongkang * @version   * @since    JDK 1.6 * @see       */public class Singleton2 {    /**     * volatile 变量.用来确保将变量的更新操作通知到其他线程,保证了新值能立即同步到主内存,以及每次使用前立即从主内存刷新     */    private static volatile Singleton2 instance = null;    private Singleton2() {}    /**     *      * getInstance: 双重检查锁定. <br/>     *     * @author qiyongkang     * @return     * @since JDK 1.6     */    public static Singleton2 getInstance() {        if (instance == null) {            synchronized (Singleton2.class) {                if (instance == null) {                    instance = new Singleton2();                }            }        }        return instance;    }}

这里，对比上一种方法，在性能方面有所改进，将同步关键字放在方法里面。然后，就是为什么使用volatile关键字以及两次为空判断，大家可以仔细体会一下，这个主要是防止在多线程中出现问题。
3、静态内部类

package org.wuqiong.designpattern.singlepattern.lazyType;/** * ClassName:Singleton3 <br/> * Function: 单例模式-懒汉式，静态内部类. <br/> * Date:     2016年1月29日 下午2:09:31 <br/> * @author   qiyongkang * @version   * @since    JDK 1.6 * @see       */public class Singleton3 {    private static class LazyHolder {        private static final Singleton3 INSTANCE = new Singleton3();    }    private Singleton3() {}    /**     *      * getInstance:静态内部类. <br/>     *     * @author qiyongkang     * @return     * @since JDK 1.6     */    public static final Singleton3 getInstance() {        return LazyHolder.INSTANCE;    }}

这种方法，大家可以好好体会一下，应该比以上两种方法都要好，一般比较推荐使用这种方法。

3、登记式

/** * ClassName:Singleton <br/> * Function: 单例模式-登记式 <br/> * Reason: TODO ADD REASON. <br/> * Date: 2016年1月29日 下午2:16:36 <br/> *  * @author qiyongkang * @version * @since JDK 1.6 * @see */public class Singleton {    private static Map<String, Singleton> map = new HashMap<String, Singleton>();    static {        Singleton single = new Singleton();        map.put(single.getClass().getName(), single);    }    // 保护的默认构造子    protected Singleton() {    }    // 静态工厂方法,返还此类惟一的实例    public static Singleton getInstance(String name) {        if (name == null) {            name = Singleton.class.getName();            System.out.println("name == null" + "--->name=" + name);        }        if (map.get(name) == null) {            try {                map.put(name, (Singleton) Class.forName(name).newInstance());            } catch (InstantiationException e) {                e.printStackTrace();            } catch (IllegalAccessException e) {                e.printStackTrace();            } catch (ClassNotFoundException e) {                e.printStackTrace();            }        }        return map.get(name);    }    // 一个示意性的商业方法    public String about() {        return "Hello, I am RegSingleton.";    }    public static void main(String[] args) {        Singleton single3 = Singleton.getInstance(null);        System.out.println(single3.about());    }}

仔细看看，其实登记式和饿汗式差不多，也是在类加载的时候实例化一次，只不过会把此对象放入map中注册一下。这种方式，其实和spring中的做法很相似，都是通过反射的机制实例化对象。
那么，单例模式就讲到这儿了，希望对单例模式还不太了解的童鞋提供点帮助！