六种常用的设计模式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中的做法很相似，都是通过反射的机制实例化对象。
那么，单例模式就讲到这儿了，希望对单例模式还不太了解的童鞋提供点帮助！