单例模式

/**
 * 面试:谈谈你对单例模式的认识?
 * 对象单例设计:(设计类时保证类的实例在内存中只有一份)
 * 1)内部设计实现(对类自身进行设计)
 * 2)外部设计实现(对类的对象提供一种池)
 */

单例模式的设计目的
单例模式保证一个类仅有一个实例，并提供一个访问它的全局访问点；
（1）基于全局访问点的思想，很容易想到定义全局或者静态对象，但是这样不能保证该类只声明一个静态对象，并没有实现仅有一个对象的思想；
（2）单例模式设计方式
• 将类的构造函数写在私有下；
• 定义一个静态的指针指向该类唯一的对象；
• 定义一个公有下返回该对象的静态方法

package com.java.oop.instance;

class Single2 {
	private Single2() {
		System.out.println("调用了Single2()......");
	}

	private static  Single2 instance;

	public static Single2 getInstance() {
		if (instance == null) {
			instance = new Single2();
		}
		return instance;
	}
}

public class Test2 {
	public static void main(String[] args) throws Exception {
		show();
	}

	private static void show() throws Exception {

		// 局部内部类
		class Task implements Runnable {
			@Override
			public void run() {
				Single2.getInstance();
			}
		}
		Thread t1 = new Thread(new Task());
		Thread t2 = new Thread(new Task());
		Thread t3 = new Thread(new Task());
		t1.start();
		t2.start();
		t3.start();
	}
}

这种设计在多线程情况下不安全
调用了Single2()…
会随机出现 1,2,3次
所以我们要对其优化

---

单例模式优化之一

package com.java.oop.instance;
/**方案1:线程安全的单例设计   大对象，并发访问少 */
//锁加双重验证    线程安全 
class Single {
	private Single() {
		System.out.println("-------");
	}
	private static volatile Single instance;
	public static Single getInstance() {
		if (instance == null) {
			synchronized (Single.class) {
				if (instance == null) {
					instance = new Single();
				}
			}
		}
		return instance;
	}
}

单例模式优化之二

/**方案2:线程安全的单例设计    小对象，频繁访问 */
//线程安全 无阻塞
//缺陷:可能占用资源比较多，尤其是大对象
//类加载时  对象创建且 只创建一次
class Singleton{
	private Singleton(){ }
	private static Singleton instance = new Singleton();
	private static Singleton getInstance() {
		return instance;
	}
}

单例模式优化之三

/**方案4:    大对象   频繁用（高并发  大量访问）*/
class Singleton04{
	private Singleton04(){ }
	//通过内部类实现属性的延迟初始化(懒加载  延迟加载)
	static class Inner{
		private static Singleton04 instance = new Singleton04();
	}
	private static Singleton04 getInstance() {
		return Inner.instance;
	}
	public static void show(){}
	
}