java是一种可以撰写跨平台应用软件的面向对象的程序设计语言,是由Sun Microsystems公司于1995年5月推出的Java程序设计语言和Java平台(即JavaEE, JavaME, JavaSE)的总称。本站提供基于Java框架struts,spring,hibernate等的桌面应用、web交互及移动终端的开发技巧与资料

保持永久学习的心态,将成就一个优秀的你,来 继续搞起java知识。

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

一、基本概念

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

二、分类及含义

单例模式的分类有好几种,把以下三种搞清楚就够了。

饿汉式:在第一次调用的时候实例化自己 懒汉式:在类初始化时,已经自行实例化,三种实现,synchronized、双重检查锁定、静态内部类

登记式:类似Spring里面的方法,将类名注册,下次从里面直接获取

三、代码实现

1、饿汉式

这里,我先直接贴出代码:

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同步方法

1/**
 * 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、双重检查锁定

1package 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、静态内部类

1package 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、登记式

1/**
 * 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中的做法很相似,都是通过反射的机制实例化对象。

那么,单例模式就讲到这儿了,希望对单例模式还不太了解的童鞋提供点帮助!

java设计模式实例spring单例模式

因为水平有限,难免有疏忽或者不准确的地方,希望大家能够直接指出来,我会及时改正。一切为了知识的分享。

后续会有更多的精彩的内容分享给大家。