1. 全局变量的缺点：
必须在程序一开始就创建好对象，如果程序在这次的执行过程中又一直没用到它，就非常耗费资源。
2. 经典的单例模式实现：
- public class Singleton {
- //用一个静态变量来记录Singleton类的唯一实例
- private static Singleton uniqueInstance;
- private Singleton() {}
- //注意这个方法也是静态的
- public <SPAN style="COLOR: #ff0000">static</SPAN> Singleton getInstance() {
- if(uniqueInstance == null) {
- uniqueInstance = new Singleton();
- }
- return uniqueInstance;
- }
- }
- public class Singleton {
- //用一个静态变量来记录Singleton类的唯一实例
- private static Singleton uniqueInstance;
- private Singleton() {}
- //注意这个方法也是静态的
- public <SPAN style="COLOR: #ff0000">static</SPAN> Singleton getInstance() {
- if(uniqueInstance == null) {
- uniqueInstance = new Singleton();
- }
- return uniqueInstance;
- }
- }
public class Singleton {
//用一个静态变量来记录Singleton类的唯一实例
private static Singleton uniqueInstance;
private Singleton() {}
//注意这个方法也是静态的
public static Singleton getInstance() {
if(uniqueInstance == null) {
uniqueInstance = new Singleton();
}
return uniqueInstance;
}
}
单例常被用来管理共享的资源，例如数据库连接、线程池、缓存、注册表。
单例模式确保一个类只有一个实例，并提供一个全局访问点。
这个模式的问题：在多线程时，并不能保证这个类只被实例化一次。
3. 处理多线程：
public class Singleton {
- //用一个静态变量来记录Singleton类的唯一实例
- private static Singleton uniqueInstance;
- private Singleton() {}
- //注意这个方法也是静态的
- public static <SPAN style="COLOR: #ff0000">synchronized</SPAN> Singleton getInstance() {
- if(uniqueInstance == null) {
- uniqueInstance = new Singleton();
- }
- return uniqueInstance;
- }
- }
- //用一个静态变量来记录Singleton类的唯一实例
- private static Singleton uniqueInstance;
- private Singleton() {}
- //注意这个方法也是静态的
- public static <SPAN style="COLOR: #ff0000">synchronized</SPAN> Singleton getInstance() {
- if(uniqueInstance == null) {
- uniqueInstance = new Singleton();
- }
- return uniqueInstance;
- }
- }
//用一个静态变量来记录Singleton类的唯一实例
private static Singleton uniqueInstance;
private Singleton() {}
//注意这个方法也是静态的
public static synchronized Singleton getInstance() {
if(uniqueInstance == null) {
uniqueInstance = new Singleton();
}
return uniqueInstance;
}
}通过增加synchronized关键字到getInstance()方法中，迫使每个线程在进入方法之前，要先等别的线程离开该方法。也就是说，不会有两个线程可以同时进入这个方法。
这种方法存在的问题：只有第一次执行此方法时，才真正需要同步。换句话说，一旦设置好uniqueInstance变量，就不再需要同步这个方法了。之后每次调用这个方法，同步都是一种浪费。
4.改善多线程
4.1 如果getInstance()的性能对应用程序不是很关键，就不用优化了
4.2 使用急切创建实例，而不用延迟实例化的做法
- public class Singleton {
- <SPAN style="COLOR: #ff0000">private static Singleton uniqueInstance = new Singleton();</SPAN>
- private Singleton() {}
- public static Singleton getInstance() {
- return uniqueInstance;
- }
- }
- public class Singleton {
- <SPAN style="COLOR: #ff0000">private static Singleton uniqueInstance = new Singleton();</SPAN>
- private Singleton() {}
- public static Singleton getInstance() {
- return uniqueInstance;
- }
- }
public class Singleton {
private static Singleton uniqueInstance = new Singleton();
private Singleton() {}
public static Singleton getInstance() {
return uniqueInstance;
}
}标红的语句在静态初始化器(static initializer)中创建单例，这保证了线程安全。
利用这个做法，JVM在加载这个类时马上创建此唯一的单件实例。JVM保证任何线程访问uniqueInstance静态变量之前，一定先创建些实例。
4.3 用“双重检查加锁”，在getInstance()中减少使用同步
首先检查实例是否已经创建，如果尚未创建，才进行同步。这样一来，只有第一次会同步，这正是我们想要的。
- public class Singleton {
- private volatile static Singleton uniqueInstance;
- private Singleton() {}
- public static Singleton getInstance() {
- if(uniqueInstance == null) { //(1)
- //只有第一次才彻底执行这里的代码
- synchronized() {
- //再检查一次
- if(uniqueInstance == null)
- uniqueInstance = new Singleton();
- }
- }
- return uniqueInstance;
- }
- }
- public class Singleton {
- private volatile static Singleton uniqueInstance;
- private Singleton() {}
- public static Singleton getInstance() {
- if(uniqueInstance == null) { //(1)
- //只有第一次才彻底执行这里的代码
- synchronized() {
- //再检查一次
- if(uniqueInstance == null)
- uniqueInstance = new Singleton();
- }
- }
- return uniqueInstance;
- }
- }
public class Singleton {
private volatile static Singleton uniqueInstance;
private Singleton() {}
public static Singleton getInstance() {
if(uniqueInstance == null) { //(1)
//只有第一次才彻底执行这里的代码
synchronized() {
//再检查一次
if(uniqueInstance == null)
uniqueInstance = new Singleton();
}
}
return uniqueInstance;
}
}在最开始如果有1、2、3个线程走到了(1)处，假设1进入了同步块，2、3等待。1实例化后，2进入同步块，发现uniqueInstance已经不为空，跳出同步块。接着3进入，又跳出同步块。
volatile关键字确保：当uniqueInstance变量被初始化成Singleton实例时，多个线程正确地uniqueInstance变量。如果性能是你关心的重点，那么这个做法可以帮你大大地减少getInstance()的时间耗费。
Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。
而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。
这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
Java语言规范中指出：为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而且只当线程进入或者离开同步代码块时才与共享成员变量的原始值对比。这样当多个线程同时与某个对象交互时，就必须要注意到要让线程及时的得到共享成员变量的变化。
而volatile关键字就是提示VM：对于这个成员变量不能保存它的私有拷贝，而应直接与共享成员变量交互。
使用建议：在两个或者更多的线程访问的成员变量上使用volatile。当要访问的变量已在synchronized代码块中，或者为常量时，不必使用。由于使用volatile屏蔽掉了VM中必要的代码优化，所以在效率上比较低，因此一定在必要时才使用此关键字。
第一种（懒汉，线程不安全）：
- public class Singleton {
- private static Singleton instance;
- public static Singleton getInstance() {
- if (instance == null) {
- instance = new Singleton();
- }
- return instance;
- }
- }
这种写法lazy loading很明显，但是致命的是在多线程不能正常工作。
第二种（懒汉，线程安全）：
- public class Singleton {
- private static Singleton instance;
- public static synchronized Singleton getInstance() {
- if (instance == null) {
- instance = new Singleton();
- }
- return instance;
- }
- }
这种写法能够在多线程中很好的工作，而且看起来它也具备很好的lazy loading，但是，遗憾的是，效率很低，99%情况下不需要同步。
第三种（饿汉）：
- public class Singleton {
- private static Singleton instance = new Singleton();
- public static Singleton getInstance() {
- return instance;
- }
- }
这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用getInstance方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到lazy loading的效果。
第四种（饿汉，变种）：
- public class Singleton {
- private Singleton instance = null;
- static {
- instance = new Singleton();
- }
- public static Singleton getInstance() {
- return this.instance;
- }
- }
表面上看起来差别挺大，其实更第三种方式差不多，都是在类初始化即实例化instance。
第五种（静态内部类）：
- public class Singleton {
- private static class SingletonHolder {
- private static final Singleton INSTANCE = new Singleton();
- }
- public static final Singleton getInstance() {
- return SingletonHolder.INSTANCE;
- }
- }
这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程，它跟第三种和第四种方式不同的是（很细微的差别）：第三种和第四种方式是只要Singleton类被装载了，那么instance就会被实例化（没有达到lazy loading效果），而这种方式是Singleton类被装载了，instance不一定被初始化。因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance。想象一下，如果实例化instance很消耗资源，我想让他延迟加载，另外一方面，我不希望在Singleton类加载时就实例化，因为我不能确保Singleton类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化instance显然是不合适的。这个时候，这种方式相比第三和第四种方式就显得很合理。
第六种（枚举）：
- public enum Singleton {
- INSTANCE;
- public void whateverMethod() {
- }
- }
这种方式是Effective Java作者Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，可谓是很坚强的壁垒啊，不过，个人认为由于1.5中才加入enum特性，用这种方式写不免让人感觉生疏，在实际工作中，我也很少看见有人这么写过。
第七种（双重校验锁）：
- public class Singleton {
- private volatile static Singleton singleton;
- public static Singleton getSingleton() {
- if (singleton == null) {
- synchronized (Singleton.class) {
- if (singleton == null) {
- singleton = new Singleton();
- }
- }
- }
- return singleton;
- }
- }
这个是第二种方式的升级版，俗称双重检查锁定，详细介绍请查看：http://www.ibm.com/developerworks/cn/java/j-dcl.html
在JDK1.5之后，双重检查锁定才能够正常达到单例效果。
总结
有两个问题需要注意：
1.如果单例由不同的类装载器装入，那便有可能存在多个单例类的实例。假定不是远端存取，例如一些servlet容器对每个servlet使用完全不同的类装载器，这样的话如果有两个servlet访问一个单例类，它们就都会有各自的实例。
2.如果Singleton实现了java.io.Serializable接口，那么这个类的实例就可能被序列化和复原。不管怎样，如果你序列化一个单例类的对象，接下来复原多个那个对象，那你就会有多个单例类的实例。
对第一个问题修复的办法是：
- private static Class getClass(String classname)
- throws ClassNotFoundException {
- ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
- if(classLoader == null)
- classLoader = Singleton.class.getClassLoader();
- return (classLoader.loadClass(classname));
- }
- }
对第二个问题修复的办法是：
- public class Singleton implements java.io.Serializable {
- public static Singleton INSTANCE = new Singleton();
- protected Singleton() {
- }
- private Object readResolve() {
- return INSTANCE;
- }
- }
对我来说，我比较喜欢第三种和第五种方式，简单易懂，而且在JVM层实现了线程安全（如果不是多个类加载器环境），一般的情况下，我会使用第三种方式，只有在要明确实现lazy loading效果时才会使用第五种方式，另外，如果涉及到反序列化创建对象时我会试着使用枚举的方式来实现单例，不过，我一直会保证我的程序是线程安全的，而且我永远不会使用第一种和第二种方式，如果有其他特殊的需求，我可能会使用第七种方式，毕竟，JDK1.5已经没有双重检查锁定的问题了。
========================================================================
superheizai同学总结的很到位：
不过一般来说，第一种不算单例，第四种和第三种就是一种，如果算的话，第五种也可以分开写了。所以说，一般单例都是五种写法。懒汉，恶汉，双重校验锁，枚举和静态内部类。
我很高兴有这样的读者，一起共勉。
本文深入讲解JAVA1.5新特性之一的枚举，对其概念，应用做了详尽的描述，目的在于帮助学员更好的理解SCJP认证考试中关于枚举的题目，并且在开发中能够灵活使用枚举。本文包括以下内容：
一.枚举（enum）的概念(枚举是不是类)
二.为什么要有枚举
三.枚举与单例模式
四.枚举与策略模式
一.枚举的概念
关于枚举的概念，我们可以先提一个问题，对于一切都是类一切都是对象的JAVA语言来说，枚举是不是类？
enum除了不能继承之外,可以定义构造器，有正常的方法，甚至是抽象方法，因此基本上可以将enum看做一个常规的类。既然可以把它看作是一个常规的类，我们不妨写一个类模拟枚举。
本文的案例场景：以我们迈胜（mison）的企业理念以及各个岗位的工作职责为例：
- public class Misoner {
- private Misoner() {}
- //讲师
- public static final Misoner TECHNICAL_ADVISER = new Misoner();
- //就业指导
- public static final Misoner EMPLOYMENT_GUIDE = new Misoner();
- //软件外包
- public static final Misoner SOFTWARE_DEVELOPMENT = new Misoner();
- //咨询中心
- public static final Misoner CONSULTING_CENTER = new Misoner();
- }
- public enum MisonerEnum{
- // 讲师，就业指导中心，软件外包中心，咨询中心
- TECHNICAL_ADVISER, EMPLOYMENT_GUIDE, SOFTWARE_DEVELOPMENT, CONSULTING_CENTER;
- }
接下来再提两个问题：
1.枚举的构造器怎么调用?
2.枚举的抽象方法如何实现？
先看第1个问题：
- package complex;
- public class Misoner {
- private Misoner(String position) {
- System.out.println("岗位：" + position);
- }
- public static final Misoner TECHNICAL_ADVISER = new Misoner("技术总监");
- public static final Misoner EMPLOYMENT_GUIDE = new Misoner("就业指导");
- public static final Misoner SOFTWARE_DEVELOPMENT = new Misoner("项目经理");
- public static final Misoner CONSULTING_CENTER = new Misoner("咨询顾问");
- }
- package complex;
- public enum MisonerEnum {
- TECHNICAL_ADVISER("技术总监"), EMPLOYMENT_GUIDE("就业指导"), SOFTWARE_DEVELOPMENT(
- "项目经理"), CONSULTING_CENTER("咨询顾问");
- private MisonerEnum(String position) {
- System.out.println("岗位：" + position);
- }
- }
- package complex;
- public abstract class Misoner {
- private Misoner(String position) {
- System.out.println("岗位：" + position);
- }
- // 定义内部类对象
- public static final Misoner TECHNICAL_ADVISER = new Misoner("技术总监") {
- public void work() {
- System.out.println("讲师提供一流的JAVA技术培训");
- }
- };
- public static final Misoner EMPLOYMENT_GUIDE = new Misoner("就业指导") {
- public void work() {
- System.out.println("就业指导中心帮助学员实现高薪就业");
- }
- };
- public static final Misoner SOFTWARE_DEVELOPMENT = new Misoner("项目经理") {
- public void work() {
- System.out.println("软件外包中心为学员提供商业外包带薪实战");
- }
- };
- public static final Misoner CONSULTING_CENTER = new Misoner("咨询顾问") {
- public void work() {
- System.out.println("咨询中心为学员提供生活学习上的一切服务");
- }
- };
- //定义抽象方法
- public abstract void work();
- }
- package complex;
- public enum MisonerEnum {
- TECHNICAL_ADVISER("技术总监") {
- public void work() {
- System.out.println("讲师提供一流的JAVA技术培训");
- }
- }, EMPLOYMENT_GUIDE("就业指导") {
- public void work() {
- System.out.println("就业指导中心帮助学员实现高薪就业");
- }
- }, SOFTWARE_DEVELOPMENT("项目经理") {
- public void work() {
- System.out.println("软件外包中心为学员提供商业外包带薪实战");
- }
- }, CONSULTING_CENTER("咨询顾问") {
- public void work() {
- System.out.println("咨询中心为学员提供生活学习上的一切服务");
- }
- };
- private MisonerEnum(String position) {
- System.out.println("岗位：" + position);
- }
- public abstract void work();
- }
通过模拟的枚举类以及JDK1.5提供的枚举的比较，相信大家对枚举的概念会了然于心，枚举的难点便是构造器以及抽象方法。
JDK 1.5引入枚举，通过枚举，我们也可以实现单例模式，不仅仅是单例哦，以下是稍微拓展之后的代码：
public enum SingletonEnum
{
INSTANCE01,INSTANCE02;
private String name;
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
}
测试
public class Test
{
public static void main(String[] args)
{
SingletonEnum instance01=SingletonEnum.INSTANCE01;
instance01.setName("terje");
System.out.println(instance01.getName());
SingletonEnum instance02=SingletonEnum.INSTANCE01;
System.out.println(instance02.getName());
SingletonEnum instance03=SingletonEnum.INSTANCE02;
instance03.setName("liu");
System.out.println(instance03.getName());
SingletonEnum instance04=SingletonEnum.INSTANCE02;
instance04.setName("liu");
System.out.println(instance04.getName());
}
}
输出：
terje
terje
liu
liu
扫一扫
1746
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
