02-创建型---单例模式

创建型—单例模式

---

前言：

单例模式

核心在于 构造方法私有化，即不允许 外部调用该类的构造方法；

直接实例化

---

package creat;
/**
 * 直接实例化
 * 构造方法 被定义成private，避免被外部调用，这是实现单例对象的关键
 * 直接定义 静态成员变量 single，并通过new Single_Demo01()方法完成初始化，之后不在变化，线程安全；
 * 外部类 可通过静态getInstance()方法返回单例对象的实例
 * @author hp
 *
 */
public class Singleton_Demo01 {
		//构造方法私有化
		private Singleton_Demo01() {}
		//直接产生 单例实例
		private static final Singleton_Demo01 singleton = new Singleton_Demo01();
		//提供单例对象方法
		public static Singleton_Demo01 getInstance() {
				return singleton;
		}
	

}

延迟实例化

这里存在 线程安全问题 ，建议不要使用该方法；

package creat;
/**
 * 延迟实例化 基础版本
 * 构造函数被private修饰 ，避免外部调用；
 *  单例成员变量single 首先初始化 为null； 在getInstance()方法内部完成 延迟实例化，
 *  返回单例对象，但是存在线程安全问题
 * @author hp
 *
 */
public class Singleton_Demo011 {
	private Singleton_Demo011() {}
	private static Singleton_Demo011 single = null;
	public static Singleton_Demo011 getInstance() {
		if(single==null)
			single = new Singleton_Demo011();
		return single;
	}
}

完全同步实例化

不追求 效率，强调安全时使用，毕竟是串行

---

package creat;
/**
 * 优化 延迟实例化的方案 1： 完全同步法
 * 多线程同时访问 getInstance()方法的时候，多线程是  串行　　
 * 一个线程必须完全执行完　getInstance()方法 后，下一个线程才能调用该方法
 * @author hp
 *
 */
public class Singleton_Demo012 {
	
	private Singleton_Demo012() {}
	private static Singleton_Demo012 single = null;
	public static synchronized Singleton_Demo012 getInstance() {
		if(single==null)
			single = new Singleton_Demo012();
		return single;
	}
}

部分同步实例化

---

package creat;
/**
 * 延迟实例化——优化方法——部分同步法
 * 在方法getInstance() 内有些代码 并行运行， 有些代码 同步（串行）运行；
 * 与 完全同步法相比较  ， 提高运行效率
 * 使用 双重锁部分同步机制 来获取单例对象
 * @author hp
 *
 */
public class Singleton_Demo013 {
		private Singleton_Demo013() {}
		
		private static Singleton_Demo013 singleton;
		
		public static Singleton_Demo013 getInstance() {
			if(singleton==null) {
				synchronized(Singleton_Demo013.class) {
					if(singleton ==null) {
						singleton = new Singleton_Demo013();
					}
				}
			}
			return singleton ;
		}
		
}

静态内部类实例化

---

静态内部类相比较之前的通过关键字synchronized来将，提高Java虚拟机的维护效率，通过静态内部类My来实现单例对象；

	
	public class Singleton {

    private Singleton(){
        System.out.println("This is a new Instance !");
    }
    private static class My{
        private static final Singleton single = new Singleton();
    }
    public static final Singleton getInstance(){
        return My.single;
    }
    /*最大的不同点在于 没有使用同步机制，提供Java虚拟机的维护效率， 通过静态内部类My来实现单例对象； 线程安全
    *
    * 自己手动运行Test。Java文件，阅读注释中的 文档*/
        
        
        public class Test {
    public static void main(String [] args){
        Scanner scanner = new Scanner(System.in);
        scanner.nextLine();
        Singleton obj = Singleton.getInstance();
        Singleton obj2 = Singleton.getInstance();

    }
    /*运行到 scanner.nextLine(）；
    * 输入任意字符，才运行obj所在的代码行，此时 运行静态内部类My中的代码 singe = new Singleton（）; 从而产生单例对象；
    * 执行到obj2时，不会调用My中的代码，直接返回已产生的单例对象
    *
    * 所以 ， 在 其中直接定义成员变量 private static final Singleton single = new Singleton();
    * 导致Java虚拟机加载时，第一次生成，往后直接生成；
    * 总得来说 ，单例模式中 首推使用静态内部类来 设计单例对象*/
}