单例模式的设计与实现

#单例模式 （系统内存中该类只存在一个 实例对象，节省了系统资源）

# 一：饿汉式（线程安全，直接创建对象，可能会消耗空间） 
	* 构造方法私有:private 修饰
	* 直接创建一个实例对象：private修饰(或则再同步代码块中进行对象的创建)
	* 通过一个方法，进行实例对象的返回
	* 
# 二：懒汉式
	* 构造方法私有化：private修饰
	* 先进行对象是否为null，再进行对象的创建
	* 通过方法，将实例对象进行返回
	
   （1）直接使用if(instance==null)进行判断，线程不安全，有多个线程进来时

class Lazy1 {

    private Lazy1() {

    }

    private static Lazy1 lazy;

    /**
     * 当多个线程进入时 if(lazy==null) 会产生线程不安全的
     * @return
     */
    public static Lazy1 getIns() {
        if (lazy == null) {
            lazy = new Lazy1();
        }
        return lazy;
    }
 }

   （2）用synchronized对 返回实例的方法进行修饰（降低了程序的效率）

 public static synchronized Lazydemo2 getIns() {
        if (lazy == null) {
            lazy = new Lazydemo2();
        }
        return lazy;
    }

	（3）使用双重检查，volatile对实例对象进行修饰（可以修改），在返回实例对象时用synchronized修饰，两次进行 实例对象 null的判断

		`//volatile 使得实例对象 具有可见性

 private static volatile DoubleCheck Instance;

    public static DoubleCheck getInstance() {

        if (Instance == null) {
            /*
            锁对象：整个类
            synchronized:线程安全
            再一次进行判断：增加了程序的效率
             */
            synchronized (DoubleCheck.class) {
                if (Instance == null) {
                    Instance = new DoubleCheck();
                }
            }
        }

        return Instance;
    }
		

# 使用静态内部类的方式
	* 内部类用static 修饰，只会加载一次（提高了程序的效率）
	* 在静态内部类中 创建实例化对象 
			* 

class LazyInner {
		
		    private LazyInner() {
		    }
		
		    //用静态 static修饰 表示只会加载一次
		    private static class LazyInnerDemo {
		        private static final LazyInner lazyInner = new LazyInner();
		    }
		
		    public static LazyInner getIns() {
		        return LazyInnerDemo.lazyInner;
		    }
		
		}

# 使用枚举类型
	* enum 类名{
	* 属性
	}

enum Singletons {
	    //定义一个属性
	    Instance;
	
	}
	  Singletons singletons = Singletons.Instance;

单例模式 的创建中推荐使用

* 枚举类型
* 静态内部类
* 懒汉式（双重检查 volatile 修饰 实例对象 synchronized对返回实例方法进行加锁，两次使用 if(==null)）进行双重判断
* 饿汉式 （线程安全，占用内存空间）
*

单例模式在jdk中的使用

* java.lang.Runtime 使用的是单例模式(饿汉式)

 public class Runtime {
    	private static Runtime currentRuntime = new Runtime();

        public static Runtime getRuntime() {
        return currentRuntime;
  		  }

 	     private Runtime() {}

#单例模式的使用场景
* 需要频繁的进行创建对象何销毁对象，eg:工具类对象，避免了创建对象时的耗时操作，或消耗的资源过多的情况。