设计模式-单例模式

单例模式:

有些时候，我们只能创建一个对象，比如说：我们的回收站只能创建一次，此时我们就需要使用到单例模式。

1.饿汉模式：不会产生安全问题，因为类加载的时候该对象就被创建好了

class DanLi {
     private DanLi(){} // 将构造方法私有化 让外部不能创建对象
     private static  DanLi dl = new DanLi(); // 将对象提前创建好,当类加载的时候就创建了对象
     public static DanLi getDanLi(){ // 当调用方法时直接返回对象
           return dl;
     }
}

2.懒汉模式：线程安全，但是效率低

class DanLi2{
	// 将对象私有化 外部不能创建对象
    private DanLi2(){} 
    // 当类被加载的时候,该对象被赋为 null
    private static DanLi2 danLi = null; 
    // 将该方法同步处理,就不会出现安全问题了,也是最简单的方式,锁对象是该类的 .class 文件对象
    public static synchronized DanLi2 getDanLi(){  
        if(danLi == null){   // 当 danLi 变量为 null 的时候  也就是第一次创建对象的时候
            // 如果模拟延时 不给方法加锁的话 会出现安全问题,多个线程竞争资源 会创建多个对象
            danLi = new DanLi2(); //创建对象
        }
    	return danLi; //返回对象
 	}
}

改进版：

class DanLi2_Super{
	private DanLi2_Super(){}
    private static DanLi2_Super danLi = null;
    public static  DanLi2_Super getDanLi(){
    	synchronized (DanLi2_Super.class) { //这里加锁,提高效率
        	if (danLi == null) {
            	try {
                	Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                danLi = new DanLi2_Super();
            }
          }
          return danLi;
    }
}


class MyRunnable implements Runnable{
     @Override
     public void run() {  //在这里加锁没用的 多线程会依次进去 哪里会出现同步问题 就在哪里加锁
           System.out.println(DanLi2.getDanLi());
     }
}

public class DanLiDemo{
	public static void main(String[] args) {
    	for (int i = 0; i < 100; i++) { //饿汉模式不会出现安全问题
        	new Thread(new MyRunnable()).start();
        }
        for (int i = 0; i < 100; i++) { //懒汉模式如果不进行同步处理的话 会出现安全问题
            new Thread(new MyRunnable()).start();;
        }
	}
}