单例模式

单例模式

• 只能返回一个实例
• 自己创建自己的一个实例

懒汉式
优点：第一次调用才初始化，避免内存浪费。
缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。

//懒汉式，线程不安全
/**
 * 1.私有化的构造函数
 * 2.私有的静态的全局变量
 * 3.公有的静态的方法
 */
public class Singleton {
	private Singleton() {}
	private static Singleton singleton;
	public static Singleton getsingleton() {		
		if(singleton==null) {
			singleton=new Singleton();
		}
		return singleton;	
	}
}

//懒汉式，线程安全
public class Singleton1 {
	private static Singleton1 singleton1;
	
	private Singleton1() {}
	
	public static synchronized Singleton1 getsingleton1() {
		if(singleton1==null) {
			singleton1=new Singleton1();
		}
		return singleton1;
	}

}

饿汗式
容易产生垃圾对象
优点：没有加锁，执行效率会提高。
缺点：类加载时就初始化，浪费内存。

/**
 * 饿汗式
 * 
它
 * @author Administrator
 */
public class Singleton2 {
	private static Singleton2 singleton2=new Singleton2();
	private Singleton2() {}
	public static Singleton2 getSingleton2() {
		return singleton2;	
	}
}

双检锁
在多线程情况下能保持高性能

/**
 * 双检锁/双重校验锁
 * @author Administrator
 *
 */
public class Singleton3 {
	
	private volatile static Singleton3 singleton3;
	private Singleton3() {}
	public static Singleton3 getsingleton3() {
		
		if(singleton3==null) {
			synchronized (Singleton3.class) {
				if(singleton3==null) {
					singleton3=new Singleton3();
				}
			}
		}		
		return singleton3;
	}
}

静态内部类

/**
 * 登记式/静态内部类
 * @author Administrator
 *
 */
public class Singleton4 {

	private static class SingletonGetter {
		private static final Singleton4 singleton4=new Singleton4();
	}
	private Singleton4() {}

	public static final Singleton4 getSingleton4() {
		return SingletonGetter.singleton4;
	}
}

枚举

public enum Singleton5 {

	instence;
	public void Method() {  
    } 
}

不建议使用第 1 种和第 2 种懒汉方式
建议使用第 3 种饿汉方式
实现 lazy loading时，使用第 5 种登记方式
涉及到反序列化创建对象时，可以尝试使用第 6 种枚举方式
如果有其他特殊的需求，可以考虑使用第 4 种双检锁方式。