Java单例设计模式

为什么单例模式要起名叫饿汉式和懒汉式？

1. 饿汉式(静态常量)
2. 饿汉式（静态代码块）
3. 懒汉式(线程不安全)
4. 懒汉式(线程安全，同步方法)
5. 懒汉式(线程安全，同步代码块)
6. 双重检查
7. 静态内部类
8. 枚举

1.饿汉式

class Single1 {
	// 1. 构造器私有化, 外部能 new
	private Single1() {
	}

	// 2.本类内部创建对象实例
	private final static Single1 instance = new Single1();

	// 3. 提供一个公有的静态方法，返回实例对象
	public static Single1 getInstance() {
		return instance;
	}
	
//	// 4. 在静态代码块中,创建单例实例, 将步骤2替换
//	private final static Single1 instance;
//	static {
//		instance = new Single1();
//	}

}

不管程序是否需要这个对象的实例，总是在类加载的时候就先创建好实例，理解起来就像不管一个人想不想吃东西都把吃的先买好，如同饿怕了一样。

2.懒汉式

(线程不安全)(不推荐使用)

class Single2 {
	private Single2() {
	}

	private static Single2 instance;

	// 提供一个静态的公有方法，当使用到该方法时，才去创建 instance
	// 即懒汉式
	public static Single2 getInstance() {
		if (instance == null) {
			instance = new Single2();
		}
		return instance;
	}

}

1. 起到了 Lazy Loading 的效果，但是只能在单线程下使用。
2. 如果在多线程下，一个线程进入了 if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式。

如果一个对象使用频率不高，占用内存还特别大，明显就不合适用饿汉式了，这时就需要一种懒加载的思想，当程序需要这个实例的时候才去创建对象，就如同一个人懒的饿到不行了才去吃东西。

(线程安全，同步代码块)(不推荐使用)

class Single3 {
	private static Single3 instance;

	private Single3() {
	}

	//提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
	//即懒汉式
	public static synchronized Single3 getInstance() {
		if (instance == null) {
			instance = new Single3();
		}
		return instance;
	}
}

1. 解决了线程安全问题
2. 效率太低了，每个线程在想获得类的实例时候，执行 getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接 return 就行了。方法进行同步效率太低  。

(线程安全，同步代码块)(不推荐使用)

class Single4 {
	private Single4() {
	}

	private static Single4 instance;

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

---

(双重检查)(推荐使用)

• volatile 是一个类型修饰符。volatile 的作用是作为指令关键字，确保本条指令不会因编译器的优化而省略。

volatile 的特性

• 保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。（实现可见性）
• 禁止进行指令重排序。（实现有序性）
• volatile 只能保证对单次读/写的原子性。i++ 这种操作不能保证原子性。

class Single5 {
	private static volatile Single5 instance;

	private Single5() {
	}

//提供一个静态的公有方法，加入双重检查代码，解决线程安全问题, 同时解决懒加载问题
//同时保证了效率, 推荐使用

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

		}
		return instance;
	}
}

1. Double-Check 概念是多线程开发中常使用到的，如代码中所示，我们进行了两次 if (singleton == null)检查，这样就可以保证线程安全了。
2. 这样，实例化代码只用执行一次，后面再次访问时，判断 if (singleton == null)，直接 return 实例化对象，也避免的反复进行方法同步。
3. 线程安全；延迟加载；效率较高。

静态内部类(推荐使用)

class Single6 {

//构造器私有化
	private Single6() {}

//写一个静态内部类,该类中有一个静态属性 
	private static class SingleInstance {

		private static final Single6 INSTANCE = new Single6();
	}

//提供一个静态的公有方法，直接返回 
	public static synchronized Single6 getInstance() {

		return SingleInstance.INSTANCE;
	}
}

JVM底层类装载机制,线程安全。

枚举(推荐使用)

enum Single7 {
	INSTANCE; // 属性
	public void sayOK() {
		System.out.println("ok~");
	}

}

1. 这借助 JDK1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。
2. 这种方式是 Effective Java 作者 Josh Bloch  提倡的方式。

 

终于说完了,涨姿势吧。