单例设计方案实例

package com.java.oop.instance;
/**
 * 面试:谈谈你对单例模式的认识?
 * 对象单例设计:(设计类时保证类的实例在内存中只有一份)
 * 1)内部设计实现(对类自身进行设计)
 * 2)外部设计实现(对类的对象提供一种池)
 */
//如何保证如下类的设计在内存中只有一份类的实例?
//方案1:
class Singleton01{
	//构造方法私有化,不允许外界直接构建对象
	private Singleton01() {
		System.out.println("Singleton01()");
	}
	private static Singleton01 instance;
	public static Singleton01 getInstance() {
		if(instance==null) {
			instance=new Singleton01();
		}
		return instance;
	}
}//此类的设计存在线程不安全?
//出现线程不安全的原因
//1)多个线程并发执行
//2)多个线程有共享数据集
//3)多个线程在共享数据集上的操作是非原子操作.

//方案2:线程安全,有线程阻塞或少阻塞的单例设计
class Singleton02{//适合占用内存较多的对象,稀少用(并发访问少)
	//构造方法私有化,不允许外界直接构建对象
	private Singleton02() {
		System.out.println("Singleton02()");
	}
	//volatile 关键字的作用(修饰类中属性)
	//1)保证线程的可见性
	//2)禁止指令重排序
	//3)但不能保证其原子性
	//记住:当多个线程对一个共享变量进行操作时,请使用volatile修饰
	private static volatile Singleton02 instance;//如果声明对象为占用内存较多的  int array[]=new int[2048];
	//synchronized 保证代码的原子性(不能同时有多个线程对这个代码块进行访问)
	//synchronized 要让多个线程在这个代码块上顺序执行
	//此设计虽然保证了安全,但性能会被降低.
//	public synchronized static Singleton02 getInstance() {
//		if(instance==null) {
//			instance=new Singleton02();
//		}
//		return instance;
//	}
	//重构如上方法的设计,既要保证安全又要提高性能，降低多线程阻塞几率
	public static Singleton02 getInstance() {
		if(instance==null) {
		  synchronized (Singleton02.class) {
			System.out.println("synchronized");
			if(instance==null) {
				instance=new Singleton02();//分配空间,属性初始化,调用构造方法,为instance赋值
			}
		  }
		}
		return instance;
	}
	//public static void show() {} 外界访问show方法时，由于属性赋值为null,并没有声明对象，不会额外占用内存空间
}
//方案3:线程安全,无阻塞
class Singleton03{//适合:占用内存较小对象,频繁(高并发,大量访问)
	//int array[]=new int[2048];
	private Singleton03() {}
	//类加载时对象创建且只创建一次
	private static Singleton03 instance=
			new Singleton03();
	public static Singleton03 getInstance() {
		return instance;
	}
	public static void show() {}//如果外界访问show方法时，对象也会预先被创建，占用内存
}//此单例的缺陷?可能占用资源比较多,尤其是占用内存较多对象.

//单例设计方案4
class Singleton04{//占用内存较多的对象,频繁用(高并发,大量访问)
	//int array[]=new int[2048];
	private Singleton04() {}
	//通过内部类实现属性的延迟初始化(懒加载,延迟加载)
	static class Inner{
		private static Singleton04 instance=
				new Singleton04();
	}
	public static Singleton04 getInstance() {
		return Inner.instance;
	}
	//public static void show() {} 外界访问show方法时，由于静态内部类延迟加载，变量并未立即赋值，使用时再加载
}

public class TestObjectInstance03 {
	public static void main(String[] args) {
		//doTestSingleThread01();
		doTestManyThread02();
	}
 
	private static void doTestManyThread02() {
		//局部内部类
		class Task implements Runnable{
			@Override
			public void run() {
				Singleton02.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();
		
	}
	private static void doTestSingleThread01() {
		Singleton01 s1=Singleton01.getInstance();
		Singleton01 s2=Singleton01.getInstance();
	    System.out.println(s1==s2);
	}
}