多线程下单例设计模式的实现

package concurrent;

/**
* 单例设计模式与多线程 （1）立即加载与饿汉模式 （2）延迟加载与懒汉模式（3）内置静态类实现单例设计模式
* (4)枚举类实现单例设计模式
*
* @author foolishbird_lmy
*
*/
class SingletonA {
// 立即加载与饿汉模式
private static SingletonA sa = new SingletonA();

private SingletonA() {

}

public static SingletonA getInstance() {
return sa;
}
}

class SingletonB {
// 延迟加载与懒汉模式,双检查模式
private static SingletonB sb;

private SingletonB() {

}

public static SingletonB getInstance() {
// 延迟加载
if (sb == null) {
synchronized (SingletonB.class) {
if (sb == null) {
sb = new SingletonB();
}
}
}
return sb;
}
}

class SingletonC {
//内部类
private static class SingletonHandler{
private static SingletonC sc = new SingletonC();
}

private SingletonC(){

}

public static SingletonC getInstance(){
return SingletonHandler.sc;
}
}

enum SingletonD{
//使用enum枚举类实现单例模式
INSTANCE;
public void get(){
System.out.println();
}
}
class SingletonThread extends Thread {
public void run() {
System.out.println(SingletonA.getInstance().hashCode());
System.out.println(SingletonB.getInstance().hashCode());
System.out.println(SingletonC.getInstance().hashCode());
System.out.println(SingletonD.INSTANCE.hashCode());
}
}

public class TestSingleton {
public static void main(String[] args) {
SingletonThread st1 = new SingletonThread();
SingletonThread st2 = new SingletonThread();
SingletonThread st3 = new SingletonThread();
st1.start();
st2.start();
st3.start();
}
}

1、恶汉：因为加载类的时候就创建实例，所以线程安全(多个ClassLoader存在时例外)。缺点是不能延时加载。
2、懒汉：需要加锁才能实现多线程同步，但是效率会降低。优点是延时加载。
3、双重校验锁：麻烦，在当前Java内存模型中不一定都管用，某些平台和编译器甚至是错误的，因为sb = new SingletonB()这种代码在不同编译器上的行为和实现方式不可预知。
4、静态内部类：延迟加载，减少内存开销。因为用到的时候才加载，避免了静态field在单例类加载时即进入到堆内存的permanent代而永远得不到回收的缺点(大多数垃圾回收算法是这样)。
5、枚举：很好，不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。