本文参考:《修炼Java开发技术:在架构中体验设计模式和算法之美 于广编著》。
单例模式也被称为单件模式(或单体模式),主要作用是控制某个类型的实例数量是一个,而且只有一个。对于单例模式而言,不管采用何种实现方式,它都是只关心实例的创建问题,保证运行期间只会被创建一类实例,并不关心具体的业务功能。
实现单例的方式:
1、外部方式:客户程序使用某些全局对象时,做一些”Try-Use“的工作。如果没有,就自己创建一个,把它放在全局的位置,如果本来就有,直接拿过来一个现成的使用。
2、内部方式:类型自己控制生成实例的数量,无论客户程序是否尝试过了,类型自己控制只提供一个实例,客户程序使用的都是这个现成的唯一实例。
单例模式的特点:
1、该类只有一个实例。
2、该类自行创建该实例。
3、向整个系统公开这个实例接口。
单例模式的种类:
1、懒汉式单例
懒汉式单例是指在类加载的时候不创建单例实例,只有在第一次请求实例的时候创建,并且只在第一次创建后,以后不再创建该类的实例。
package org.dyb.design.singleton;
public class Singleton {
/**
* 储存创建好的实例
*/
private static Singleton instance = null;
private Singleton(){}//私有的构造器
/**
*为客户端提供实例
*@return Singleton的实例
*/
public static synchronized Singleton getInstance(){
if(null == instance)
return new Singleton();
return instance;
}
}
2、饿汉式单例
饿汉式单例是指在类被加载的时候,唯一实例已经被创建。
package org.dyb.design.singleton;
public class Singleton {
private static Singleton instance = new Singleton();//在自身被加载时实例化
private Singleton(){}//使用private禁止外部进行实例化
public static Singleton getInstance(){
return instance;
}
}
3、登记式单例
登记式单例实际上维护的是一组单例类的实例,将这些实例存放在一个Map中,对于已经登记过的实例,则从工厂直接返回,对于没有登记的,则先登记,而后返回。
package org.dyb.design.singleton;
import java.util.HashMap;
import java.util.Map;
public class RegSingleton {
/**
* 登记薄,用来存放所有登记的实例
*/
private static Map<String,RegSingleton> m_registry = new HashMap<>();
//在类加载的时候添加一个实例进去
static {
RegSingleton x = new RegSingleton();
m_registry.put(x.getClass().getName(), x);
}
protected RegSingleton(){}//同一包下或者子类可以自己实例,这样就可以管理实例组
/**
* 对于已经登记过的实例,则从工厂直接返回,对于没有登记的,则先登记,而后返回
* @return RegSingleton实例
*/
public static RegSingleton getInstance(String name){
if(null == name){
name = "RegSingleton";
}
if(m_registry.get(name) == null){
try {
m_registry.put(name, (RegSingleton)Class.forName(name).newInstance());
} catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
e.printStackTrace();
}
}
return m_registry.get(name);
}
}
双重检查加锁:
因为懒汉式的实现是线程安全的,所以会降低整个访问速度,而且每次访问都要判断一次。更好的实现方式可以使用”双重检查加锁“的方式,这样既可以实现线程安全也不会使性能受到很大的影响。
所谓的双重检查加锁机制,是指并不是每次进入getInstance方法都需要同步,而是先不同步。当进入方法后,先检查实例是否存在,如果不存在才进行下面的同步块,这是第一重检查,进入同步块后,再次检查实例是否存在,如果不存在,就在同步的情况下创建一个实例,这是第二重检查,这样以来整个过程只需要一次同步,从而减少了多次在同步情况下进行判断所浪费的时间。
在使用”双重检查加锁“机制实现时,需要使用关键字”volatile“,含义是被volatile修饰的变量的值不会被本地线程缓存,所有对该变量的读写都是直接操作共享内存,从而确保多个线程能正确地处理该变量。该机制只能用在Java5以上的版本,原因是在Java1.4以前jvm对于volatile关键字的实现存在问题。
package org.dyb.design.singleton;
public class Singleton {
/**
* 储存创建好的实例
*/
private volatile static Singleton instance = null;
private Singleton(){}//私有的构造器
public static Singleton getInstance(){
if(null == instance){
//同步块,线程安全创建实例
synchronized(Singleton.class){
if(null == instance){
instance = new Singleton();
}
}
}
return instance;
}
}
这种实现方式不但可以实现线程安全的创建实例,而且又不会对性能造成太大的影响。它只是第一次创建市里的时候同步,以后就不需要同步的了,从而加快了运行速度。因为volatile关键字可能会屏蔽掉虚拟机中一些必需的代码优化,所以运行效率并不是很高。所以在此建议读者,如果没有特别的需要,不要使用volatile关键字。也就是说,虽然可以使用”双重检查加锁“机制来实现线程安全的单例,但是不建议大量采用,可以根据情况来选用。
一种更好的方式:
上面常见的两种方式(懒汉式和饿汉式)都存在小小的缺陷,有没有一种方式既能够实现延迟加载又能够实现线程安全呢?
采用类级内部类能够让类装载的时候不去初始化对象,在这个类级内部类里面去创建对象实例,这样只要不使用到这个类级内部类,那就不会创建对象实例,从而能同时实现延迟加载和线程安全。
package org.dyb.design.singleton;
public class Singleton {
/**
*类级的内部类,也就是静态的成员式内部类,该内部类的实例与外部类的实例没有绑定关系,
*而且只有被调用到才会装载,从而实现了延迟加载
*/
private static class SingletonHolder{
private static Singleton instance = new Singleton();
}
private Singleton(){}
public static Singleton getInstance(){
return SingletonHolder.instance;
}
}
这样,当getInstance方法第一次被调用的时候,它第一次读取SingletonHolder.instance,导致SingletonHolder类得到初始化;而这个类在装载并被初始化的时候,会初始化它的静态域,从而创建Singleton的实例,由于是静态的域,因此只会被虚拟机在装载类的时候初始化一次,并由虚拟机来保证它的线程安全性。这个模式的优势在于,getInstance方法并没有被同步,并且只是执行一个域的访问,因此延迟初始化并没有增加任何访问开销。
单例和枚举:
单元素的枚举类型已经称为实现Singleton的最佳方法。Java的枚举类型实质上是功能齐全的类,因此可以有自己的属性和方法。Java枚举类型的基本思想是通过公有静态final域为每个枚举常量导出实例的类。从某个角度来讲,枚举是单例的泛型花,本质上是单元素的枚举。
package org.dyb.design.singleton;
public enum SingletonEnum {
uniqueInstance;
public void singletonOperation(){
System.out.println("hello world");
}
}
测试:
package org.dyb.design.singleton;
import org.junit.Test;
public class TestSingleton {
@Test
public void test(){
SingletonEnum.uniqueInstance.singletonOperation();
}
}
使用枚举来实现单例控制,会更加简洁,而且无偿的提供了序列化的机制,并由jvm从根本上提供保障,绝对防止多次实例化,是更简洁、高效、安全的实现单例的方式。
单例模式的本质:
单例模式的本质是控制实例的数目,单例模式是为了控制在运行期间,让某些类的实例数目只能有一个。其实我们也可以控制实例的数据是2个、3个或者多个,目的都是一样的,节省资源,有时候单个不能满足需求,怎么办?利用map将实例的对象缓存下来,客户端调用的时候通过算法返回实例,如下例子(调度算法省略):
package org.dyb.design.singleton;
import java.util.HashMap;
import java.util.Map;
public class RegSingleton {
public final static String DEFAULT_PREKEY = "Cache";
/**
* 用来记录当前正在使用哪一个实例
*/
private static int num = 1;
/**
* 最大的实例缓存数量
*/
private final static int NUM_MAX = 3;
/**
* 登记薄,用来存放所有登记的实例
*/
private static Map<String, RegSingleton> m_registry = new HashMap<>();
protected RegSingleton() {
}
/**
* 对于已经登记过的实例,则从工厂直接返回,对于没有登记的,则先登记,而后返回
*
* @return RegSingleton实例
*/
public static RegSingleton getInstance() {
String key = DEFAULT_PREKEY + num;
RegSingleton regSingleton = m_registry.get(key);//num++; 循环使用,这个可以自己写算法来替换
if (regSingleton == null) {
regSingleton = new RegSingleton();
m_registry.put(key, regSingleton);//缓存实例
}
num++;
if(num>NUM_MAX){
num = 1;
}
return regSingleton;
}
}
测试:
package org.dyb.design.singleton;
import org.junit.Test;
public class TestRegSingleton {
@Test
public void test(){
RegSingleton t1 = RegSingleton.getInstance();
RegSingleton t2 = RegSingleton.getInstance();
RegSingleton t3 = RegSingleton.getInstance();
RegSingleton t4 = RegSingleton.getInstance();
RegSingleton t5 = RegSingleton.getInstance();
RegSingleton t6 = RegSingleton.getInstance();
RegSingleton t7 = RegSingleton.getInstance();
RegSingleton t8 = RegSingleton.getInstance();
RegSingleton t9 = RegSingleton.getInstance();
System.out.println("t1 = " +t1);
System.out.println("t2 = " +t2);
System.out.println("t3 = " +t3);
System.out.println("t4 = " +t4);
System.out.println("t5 = " +t5);
System.out.println("t6 = " +t6);
System.out.println("t7 = " +t7);
System.out.println("t8 = " +t8);
System.out.println("t9 = " +t9);
}
}
结果:
t1 = org.dyb.design.singleton.RegSingleton@1d0e2c9
t2 = org.dyb.design.singleton.RegSingleton@d8fd1a
t3 = org.dyb.design.singleton.RegSingleton@1d0e17a
t4 = org.dyb.design.singleton.RegSingleton@1d0e2c9
t5 = org.dyb.design.singleton.RegSingleton@d8fd1a
t6 = org.dyb.design.singleton.RegSingleton@1d0e17a
t7 = org.dyb.design.singleton.RegSingleton@1d0e2c9
t8 = org.dyb.design.singleton.RegSingleton@d8fd1a
t9 = org.dyb.design.singleton.RegSingleton@1d0e17a
结果:147,258,369是一样的。
使用单例模式的场景:
1、要求生成唯一序列号的场景。
2、在整个项目中需要有访问一个共享访问点或者共享数据,例如一个web页面的计数器。
3、创建一个对象需要消耗的资源过多,如要访问I/O、访问数据库等资源。
4、需要定义大量的静态常量和静态方法(如工具类)的环境。也可以直接声明static形式。