Java 设计模式之Singleton

Singleton模式

    宗旨：在于确保某个类只有一个实例，并且为之提供一个全局访问点，为了防止其他工作人员实例化我们的类。

    方法：为该类创建唯一一个构造器，并将构造器设置为私有。注意：如果我们创建了其他的非私有构造器，或者根本没有为该类提供构造器，那么其他人员仍然能够实例化我们的类。

    通常单例模式在Java语言中，有两种构建方式：

• 饿汉方式:指全局的单例实例在类装载时构建， 急切初始化。
• 懒汉方式:指全局的单例实例在第一次被使用时构建，延迟初始化。

1.饿汉式单例类

    采用饿汉式的写法可避免线程安全问题，但是任何对Singleton类的访问(内部的static final变量除外，因为jvm会把它们直接编译为常量)，比如类中有另外一个static方法被访问，将会引起jvm去初始化instance，而此时我们的本意是不想加载单例类的。同时又因为没有延迟加载，最明显的缺点就是如果构造器内的方法比较耗时，则加载过程会比较长。对于一般的应用，构造方法内的代码不涉及到读取配置、远程调用、初始化IOC容器等长时间执行的情况，用这种方式是最简单的。 

//饿汉式单例类
public class Singleton1 {
	private Singleton1(){}
	
	//在自己内部定义自己一个实例，注意这是private 只供内部调用
	private static Singleton1 instance = new Singleton1();
	
	//这里提供了一个供外部访问本class的静态方法，可以直接访问　
	public static Singleton1 getInstance() {
        return instance;
    }
}

2.懒汉式单例类

//懒汉式单例类
public class Singleton2 {
	private Singleton2() {
	}
	
	private static Singleton2 instance = null;

	// 只是在第一次调用getInstance才生成对象，不受其他static方法影响！
	public static Singleton2 getInstance() {
		if (instance == null)
			instance = new Singleton2();
		return instance;
	}
}

    以上懒汉单例中，单线程是没有问题的，但多线程时就会有可能出现两个或者以上的Singletion2实例的情况。 例如：线程1在判断instance==null为真，扫行new操作时，在执行new操作之前，判断为真之后，线程2正好执行判断操作，这时instance还为null.因此，线程2也会执行new操作。以此类推，在高并发下面，就可能存在两个或者以上的Singletion2的实例。

    因此修改代码如下：

public class Singleton3 {
	private Singleton3() {
	}

	private static Singleton3 instance = null;

	//为了多线程不出错，加入了同步标志
	public static synchronized Singleton3 getInstance() {
		if (instance == null)
			instance = new Singleton3();
		return instance;
	}
}

    但getInstance会被外部线程比较频繁的调用，同步比非同步的性能消耗要昂贵很多，因此这样的做法会存在很大的额外性能消耗。因此产生如下的双重检查写法：

public class Singleton3 {
	private Singleton3() {
	}

	private static Singleton3 instance = null;

	public static Singleton3 getInstance() {
		if (instance == null) {
			synchronized (Singleton3.class) {
				if (instance == null) {
					instance = new Singleton3();
				}
			}
		}
		return instance;
	}
}

    此写法存在的问题在于singleton = new Singleton() 这句代码对于编译器来说，是分两步进行。首先初始化一个singleton对象并随意赋一个值，然后调用Singleton类的构造器赋值。因此在第一步完成后singleton == null这句判断已经不成立了，但此时singleton只是一个临时值。如果线程2此时进入getInstance，就会把这个singleton给返回出去。由于java的内存模型，双重检查并不能成功的起到作用。 

    如果我们既想使用延迟加载的好处，让类在被使用的时候才去加载，又想避免额外的同步调用开销，同时还不使用双重检查的模式，可以用初始化一个中间的容器类来解决这个问题，就可以用如下的写法： 

public class Singleton {
	private static class SingletonHolder {
		static Singleton instance = new Singleton();
	}

	public static Singleton getInstance() {
		return SingletonHolder.instance;
	}

	private Singleton() {
	}
}

    java中，只有一个类被用到的时候才被初始化。在getInstance方法被调用的时候，如果SingletonHolder类没有被加载，就会去加载，起到延迟加载的作用，同时也能保持多线程下的语义正确性。 

    如果是jdk1.5以上，还可采用enum方式来实现，也可避免多线程的问题。 

enum Singleton4 {
	INSTANCE;
	public static Singleton4 getInstance() {
		return INSTANCE;
	}

	public void test() {
		System.out.println("test");
	}
}

    引用来自：http://wangnn09.blog.163.com/blog/static/13625087320118532552725/