摘要：
这里提供了单例模式的两个实际实现，它们都是线程安全的。这里推荐第一个实现，它实现了线程安全和延迟加载packagecom.zhaoyangwoo.singleton/***Createdbyjohnon16/4/28*/publicclassSingleton｛privateSingleton（）｛｝publicstaticSingletonInstance（）｝returnSingletonHolder.INSTANCE；｝//延迟加载privatestatisticclassSingletonHolder｛staticfinalSingletonINSTANCE=newSingleton）；｝｝packagecom。zhaoyangwoo.sington/***由johnon16/4/28创建。**/publicclassSingleton2｛/**Hunger style*/privatestaticSingleton2instance=newSingleton1（）；privateSingleton3（）｛｝publicstaticSingleton2getInstance（）{returninstance；｝｝此外，我不太建议实现双重检查锁定，因为它在JDK1.4之前可能会失败。
1.定义
一个类有且仅有一个实例，并且自行实例化向整个系统提供
2.类图
3.代码示例
网上最多有8中实现方式，其中包括了很多非线程安全的实现。我觉得没有必要。这里提供单例模式的两种实用实现，均为线程安全，这里推荐第一种实现，即实现了线程安全，又实现了懒加载
package com.zhaoyangwoo.singleton; /** * Created by john on 16/4/28. */ public class Singleton {
private Singleton() { } public static Singleton getInstance() { return SingletonHolder.INSTANCE; } //通过内部类机制 实现懒加载 private static class SingletonHolder { static final Singleton INSTANCE = new Singleton(); } }
package com.zhaoyangwoo.singleton; /** * Created by john on 16/4/28. * */ public class Singleton2 {/** * 饿汉式 */ private static Singleton2 instance = new Singleton2(); private Singleton2() { } public static Singleton2 getInstance() { return instance; } }
另外这里特别提到一下，对于双重检查锁定的实现，我不是很推荐，因为其在JDK1.4版本前是有失败的可能性的。
原因在于：初始化Singleton和将对象地址写到instance字段的顺序是不确定的。在某个线程new Singleton()时，在构造方法被调用之前，就为该对象分配了内存空间并将对象的字段设置为默认值。此时就可以将分配的内存地址赋值给instance字段了，然而该对象可能还没有初始化。此时若另外一个线程来调用getInstance，取到的就是状态不正确的对象。自JDK1.5后对volatile关键字描述的字段，JVM是不会对其读写进行重排序优化，问题才得以解决。
package com.zhaoyangwoo.singleton; /** * Created by john on 16/4/28. * 双重检查锁定 */ public class Singleton3 { private static volatile Singleton3 instance = null; private Singleton3() { } public static Singleton3 getInstance() { if (instance == null) { synchronized (Singleton3.class) { if (instance == null) { instance = new Singleton3(); } } } return instance; } }
4.应用场景举例
- 日志管理应用和配置文件的读写
- 创建一个对象的消耗很大，例如访问IO，数据库等
5.JDK源码中的模式实现
java.lang.Runtime对象的创建,从源码可以看出这里是用了饿汉式的实现方式。同样使用到单例模式的有java.lang.System等
package java.lang; public class Runtime { private static Runtime currentRuntime = new Runtime(); public static Runtime getRuntime() { return currentRuntime; } /** * Don't let anyone else instantiate this class */ private Runtime() { } ... }
另外值得注意一点的是Calendar日历类，Calendar.getInstance() 看起来好像是获取日历的单例对象，其实不然
//getInstance public static Calendar getInstance() { return createCalendar(TimeZone.getDefault(), Locale.getDefault(Locale.Category.FORMAT)); } private static Calendar createCalendar(TimeZone zone, Locale aLocale) { CalendarProvider provider = LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale) .getCalendarProvider(); if (provider != null) { try { return provider.getInstance(zone, aLocale); //它的实现,其实是产生了一个新的对象，并不符合单例的定义 /* * public Calendar getInstance(TimeZone var1, Locale var2) { * return (new Builder()).setLocale(var2).setTimeZone(var1).setInstant(System.cu*rrentTimeMillis()).build(); * } */ } catch (IllegalArgumentException iae) { // fall back to the default instantiation } } Calendar cal = null; ...
if (cal == null) { if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") { cal = new BuddhistCalendar(zone, aLocale); } else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja" && aLocale.getCountry() == "JP") { cal = new JapaneseImperialCalendar(zone, aLocale); } else { cal = new GregorianCalendar(zone, aLocale); } } return cal; }
6.思考
思考如下两个问题
- 单例模式状态修改
一般单例模式是不保存或者说不改变实例的状态，如果单例模式涉及到状态修改/保存，那么其方法调用需要考虑到多线程同步问题
- 单例模式vs静态类
工作中需要读取一个配置property文件,之前的实现是这样的：
public class PropertiesGetter { private static Properties privateProperties; static { privateProperties.load(new FileInputStream(System.getProperty("configHome/web.properties")); } public static String getStringProperty(String propertyNameEnum) { return privateProperties.containsKey(propertyNameEnum)?privateProperties.getProperty(propertyNameEnum):null; } //删减无关代码 ... }
//调用是这样的
PropertiesGetter.getStringProperty("XXXX");
现在改成了单例模式
public class PropertiesGetter { private PropertiesGetter() { } private static final PropertiesGetter instance = new PropertiesGetter(); public static PropertiesGetter getInstance() { return instance; } private static Properties privateProperties = new Properties(); static { privateProperties.load(new FileInputStream(System.getProperty("configHome/web.properties")); } public String getStringProperty(PropertiesNameEnum propertyNameEnum) { return privateProperties.containsKey(propertyNameEnum)?privateProperties.getProperty(propertyNameEnum):null; } //无关代码 ... } //调用 PropertiesGetter.getInstance().getStringProperty("XXXX");
就单单这个例子而言，我也说不出两种实现方式孰优孰劣？看官有想法请指教
7.参考
1.再议单例模式和静态类
2.单例模式的7种写法
3.单例模式详解