Java设计模式之饿汉式和懒汉式
 
学习java的同学们应该都知道，饿汉式和懒汉式都是单例设计模式中的一种实现，单例设计模式又是java的23种设计模式其中之一，那么我们先认识下java的23种设计模式。
 
java设计模式：
 
设计模式分:3种类型及23种模式。
 
设计模式主要分三个类型:创建型、结构型和行为型，主要需要掌握粗体的几种设计模式。
 
1. 创建型：
 
一、Singleton，单例模式：保证一个类只有一个实例，并提供一个访问它的全局访问点
 二、Abstract Factory，抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类。
 三、Factory Method，工厂方法：定义一个用于创建对象的接口，让子类决定实例化哪一个类，Factory Method使一个类的实例化延迟到了子类。
 四、Builder，建造模式：将一个复杂对象的构建与他的表示相分离，使得同样的构建过程可以创建不同的表示。
 五、Prototype，原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。
 
2. 行为型：
 
六、Iterator，迭代器模式：提供一个方法顺序访问一个聚合对象的各个元素，而又不需要暴露该对象的内部表示。
 七、Observer，观察者模式：定义对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知自动更新。
 八、Template Method，模板方法：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，TemplateMethod使得子类可以不改变一个算法的结构即可以重定义该算法得某些特定步骤。
 九、Command，命令模式：将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化，对请求排队和记录请求日志，以及支持可撤销的操作。
 十、State，状态模式：允许对象在其内部状态改变时改变他的行为。对象看起来似乎改变了他的类。
 十一、Strategy，策略模式：定义一系列的算法，把他们一个个封装起来，并使他们可以互相替换，本模式使得算法可以独立于使用它们的客户。
 十二、China of Responsibility，职责链模式：使多个对象都有机会处理请求，从而避免请求的送发者和接收者之间的耦合关系
 十三、Mediator，中介者模式：用一个中介对象封装一些列的对象交互。
 十四、Visitor，访问者模式：表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素类的前提下定义作用于这个元素的新操作。
 十五、Interpreter，解释器模式：给定一个语言，定义他的文法的一个表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
 十六、Memento，备忘录模式：在不破坏对象的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。
 
3. 结构型：
 
十七、Composite，组合模式：将对象组合成树形结构以表示部分整体的关系，Composite使得用户对单个对象和组合对象的使用具有一致性。
 十八、Facade，外观模式：为子系统中的一组接口提供一致的界面，fa?ade提供了一高层接口，这个接口使得子系统更容易使用。
 十九、Proxy，代理模式：为其他对象提供一种代理以控制对这个对象的访问
 二十、Adapter,适配器模式：将一类的接口转换成客户希望的另外一个接口，Adapter模式使得原本由于接口不兼容而不能一起工作那些类可以一起工作。
 二十一、Decrator，装饰模式：动态地给一个对象增加一些额外的职责，就增加的功能来说，Decorator模式相比生成子类更加灵活。
 二十二、Bridge，桥模式：将抽象部分与它的实现部分相分离，使他们可以独立的变化。
 二十三、Flyweight，享元模式
 
概述
 
老师说饿汉模式是线程安全的，为什么没有用synchronized 关键词修饰？
 采用synchronized 关键词修饰与不采用synchronized 关键词修饰有什么区别？
 
因为饿汉模式这个类在加载的时候就实例化了，就算thread1和thread2同时获取它，取到的是类加载时实例化的那个变量的值，所以说是线程安全的；而懒汉式线程不安全，因为有可能thread1在if（instance==null）判断为真时进入了if体里但又没开始实例化，而这时thread2也进来了，最终就会有2个实例了。
 
懒汉式是典型的时间换空间，也就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。当然，如果一直没有人使用的话，那就不会创建实例，则节约内存空间。
 饿汉式是典型的空间换时间，当类装载的时候就会创建类实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断了，节省了运行时间。
 
饿汉式没有线程安全问题，懒汉式需要双重锁定解决可能的线程安全问题。
 饿汉式的缺点是类一加载就实例化，提前占用系统资源,需要类在使用的时候才会被加载，加载一个类，它的内部类不会被加载，调用得到实例方法的时候内部类才会加载，这样就延缓了加载时机，提高了程序运行的效率
 
懒汉式，线程不安全。
 
懒汉式，线程不安全 懒汉式需要双重锁定解决可能的线程安全问题。
 
package com.demo.Thread;

public class SingletonTest {

public static void main(String[] args) {

}

/**
 * 懒汉式，线程不安全 懒汉式需要双重锁定解决可能的线程安全问题。
 * 
 * @author liu.hb
 *
 */
public static class SingletonDemo {
	private static SingletonDemo instance;

	private  SingletonDemo() {
		super();
	}

	public static SingletonDemo getInstance() {
		instance = new SingletonDemo();
		return instance;

	}

}
 
懒汉式，线程安全 双重锁定解决可能的线程安全问题。
 
懒汉式，线程安全 双重锁定解决可能的线程安全问题。因为有可能thread1在if（instance==null）判断为真时进入了if体里但又没开始实例化，而这时thread2也进来了，最终就会有2个实例了。
 
/**
 * 懒汉式，线程安全 双重锁定解决可能的线程安全问题。
 * 因为有可能thread1在if（instance==null）判断为真时进入了if体里但又没开始实例化，
 * 而这时thread2也进来了，最终就会有2个实例了。
 * 
 * @author liu.hb
 *
 */
public static class SingletonDemoSave {
	private static SingletonDemoSave instance;

	private SingletonDemoSave() {
		super();
	}

	public static synchronized SingletonDemoSave getInstance() {
		synchronized (SingletonDemoSave.class) {
			instance = new SingletonDemoSave();
		}
		return instance;

	}

}
 
饿汉式，线程安全
 
饿汉式，线程安全 类一加载就实例化，提前占用系统资源
 
/**
 * 饿汉式，线程安全 类一加载就实例化，提前占用系统资源
 * 
 * @author liu.hb
 *
 */
public static class SingletonDemo1 {
	private static SingletonDemo1 instance = new SingletonDemo1();

	private SingletonDemo1() {
		super();
	}

	public static SingletonDemo1 getInstance() {
		return instance;
	}

}
 
饿汉式，实例方法的时候内部类才会加载
 
饿汉式，线程安全 类一加载就实例化，提前占用系统资源 调用得到实例方法的时候内部类才会加载，这样就延缓了加载时机，提高了程序运行的效率
 
/**
 * 饿汉式，线程安全 类一加载就实例化，提前占用系统资源 调用得到实例方法的时候内部类才会加载，这样就延缓了加载时机，提高了程序运行的效率
 * 
 * @author liu.hb
 *
 */
public static class SingletonDemoQuick {
	public static class SingletonHold {
		private static SingletonDemoQuick instance = new SingletonDemoQuick();
	}

	private SingletonDemoQuick() {
		super();
	}

	public static SingletonDemoQuick getInstance() {
		return SingletonHold.instance;
	}

}
}
 
源码：
 
package com.demo.Thread;

public class SingletonTest {

public static void main(String[] args) {

}

/**
 * 懒汉式，线程不安全 懒汉式需要双重锁定解决可能的线程安全问题。
 * 
 * @author liu.hb
 *
 */
public static class SingletonDemo {
	private static SingletonDemo instance;

	private SingletonDemo() {
		super();
	}

	public static SingletonDemo getInstance() {
		instance = new SingletonDemo();
		return instance;

	}

}

/**
 * 懒汉式，线程安全 双重锁定解决可能的线程安全问题。
 * 因为有可能thread1在if（instance==null）判断为真时进入了if体里但又没开始实例化，
 * 而这时thread2也进来了，最终就会有2个实例了。
 * 
 * @author liu.hb
 *
 */
public static class SingletonDemoSave {
	private static SingletonDemoSave instance;

	private SingletonDemoSave() {
		super();
	}

	public static synchronized SingletonDemoSave getInstance() {
		synchronized (SingletonDemoSave.class) {
			instance = new SingletonDemoSave();
		}
		return instance;

	}

}

/**
 * 饿汉式，线程安全 类一加载就实例化，提前占用系统资源
 * 
 * @author liu.hb
 *
 */
public static class SingletonDemo1 {
	private static SingletonDemo1 instance = new SingletonDemo1();

	private SingletonDemo1() {
		super();
	}

	public static SingletonDemo1 getInstance() {
		return instance;
	}

}

/**
 * 饿汉式，线程安全 类一加载就实例化，提前占用系统资源 调用得到实例方法的时候内部类才会加载，这样就延缓了加载时机，提高了程序运行的效率
 * 
 * @author liu.hb
 *
 */
public static class SingletonDemoQuick {
	public static class SingletonHold {
		private static SingletonDemoQuick instance = new SingletonDemoQuick();
	}

	private SingletonDemoQuick() {
		super();
	}

	public static SingletonDemoQuick getInstance() {
		return SingletonHold.instance;
	}

}
 
}

Java单例模式--------懒汉式和饿汉式
 
单件模式用途：
 单件模式属于工厂模式的特例，只是它不需要输入参数并且始终返回同一对象的引用。
 单件模式能够保证某一类型对象在系统中的唯一性，即某类在系统中只有一个实例。它的用途十分广泛，打个比方，我们开发了一个简单的留言板，用户的每一次留言都要将留言信息写入到数据库中，最直观的方法是没次写入都建立一个数据库的链接。这是个简单的方法，在不考虑并发的时候这也是个不错的选择。但实际上，一个网站是并发的，并且有可能是存在大量并发操作的。如果我们对每次写入都创建一个数据库连接，那么很容易的系统会出现瓶颈，系统的精力将会很多的放在维护链接上而非直接查询操作上。这显然是不可取的。
 如果我们能够保证系统中自始至终只有唯一一个数据库连接对象，显然我们会节省很多内存开销和cpu利用率。这就是单件模式的用途。当然单件模式不仅仅只用于这样的情况。在《设计模式：可复用面向对象软件的基础》一书中对单件模式的适用性有如下描述：
 1、当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。
 2、当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。
 
下面对单件模式的懒汉式与饿汉式进行简单介绍：
 1、饿汉式：在程序启动或单件模式类被加载的时候，单件模式实例就已经被创建。
 2、懒汉式：当程序第一次访问单件模式实例时才进行创建。
 如何选择：如果单件模式实例在系统中经常会被用到，饿汉式是一个不错的选择。
     反之如果单件模式在系统中会很少用到或者几乎不会用到，那么懒汉式是一个不错的选择。
 
饿汉模式demo：
 
 
public Simple(){
     private static Single s=new Single();        
     private Single(){
        
     }  
     public static Simple getSimple(){
         return s;
     } 

}    
 
 
一般用于枚举法：
 
 
enum Single {
    Single;

    private Single() {
        
    }

    public void print(){
        System.out.println("hello world");
    }
}
public class SingleDemo {
    public static void main(String[] args) {
        Single a = Single.Single;
        a.print();
    }
 
 
懒汉模式 demo：
 
 
class Single{
   private static Single s = null;

   public Single() {
       if (s == null)
       　　s = new Single();
       return s;
　 }
}
 
 
懒汉模式在使用时，容易引起不同步问题，所以应该创建同步"锁",demo如下
 
 
class Single1 {
    private static Single1 s = null;

    public Single1() {

    }
       //同步函数的demo
    public static synchronized Single1 getInstance() {
        if (s == null)
            s = new Single1();

        return s;
    }
    //同步代码快的demo加锁，安全高效
    public static Single1 getInStanceBlock(){
        if(s==null)
            synchronized (Single1.class) {
                if(s==null)
                    s = new Single1();
            }
        
        return s;
        
    }
}

首先，单例（Singleton）设计模式是23中设计模式的一种，应用场景也比较广泛，这里只做一个简单了解
 
目标：熟悉饿汉式的实现过程，这个地方懒汉式还是有一些线程安全问题，我们学到多线程的时候再做优化
 
 
 
 
提取一下关键路径： 某个类只能存在一个对象实例-->构造器私有化，这个实例只能在类内部定义-->调用静态方法返回这个对象，这个方法必须是静态的才能被外面调用，不然外面就要声明这个类，又矛盾了-->静态的方法里面只能访问静态成员变量，所以这个类的对象也是静态的。
 
 
 
我们通过代码上来讲一下
 
首先是饿汉式：实现过程大概个4步骤：
 
创建类、
构造器私有化、
声明这个类的对象并私有化、
声明调用这个对象的方法并public、static修饰
回头把这个类的对象也static（因为static方法只能访问类中的静态成员变量）
 
 
package com.atguigu.java2;
/*
 * 单例设计模式：
 * 1.所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例
 * 
 * 2.如何实现？
 * 		饿汉式（上来就new好对象）  vs  懒汉式(啥时候用啥是时候造）
 * 
 * 3.区分饿汉式和懒汉式
 * 		饿汉式：坏处：对象加载时间过长。
 * 			   好处：饿汉式是线程安全的。
 * 
 * 		懒汉式：好处：延迟对象的创建。
 * 			   目前的写法坏处：线程不安全。--->到多线程内容时，再修改
 */
public class Singleton {
	public static void main(String[] args) {
//		Bank bank1 = new Bank();
//		Bank bank2 = new Bank();
		
		Bank bank1 = Bank.getInstance();
		Bank bank2 = Bank.getInstance();
		
		//???这俩是同一对象吗？是的
		System.out.println(bank1 == bank2); //true
	}
}

//饿汉式单例模式
class Bank{
	
	//1.私有化类的构造器 目的是为了不让类外面造对象
	private Bank() {
		
	}
	
	//2.内部创建类的对象
	//4.要求此对象也必须声明为静态的
	private static Bank instance = new Bank();
	
	//3.提供公共的静态的方法，返回类的对象
	public static Bank getInstance() {
		return instance;
	}
	
}
 
 
 
然后是懒汉式（有线程安全风险！）
 
package com.atguigu.java2;
/*
 * 单例模式的懒汉式实现
 * 
 * 
 */
public class Singleton2 {
	public static void main(String[] args) {
		Order order1 = Order.getInstance();
		Order order2 = Order.getInstance();
		System.out.println(order1 == order2);//true
		
	}
}

//懒汉式
class Order{
	//1.私有化类的构造器
	private Order() {
		
	}
	
	//2.声明当前类对象，没有初始化
	//4.此对象也必须声明为static的
	private static Order instance = null;
	
	//3.声明一个public、static的返回当前类的对象的方法
	public static Order getInstance() {
		if(instance == null) {
			return instance = new Order();	//这个地方不能让他一直new 一直new就一直创建对象了
		}else {
			return instance;
		}
	}
}
 
 
 
 
 
PS：
 
 * 如何实现？
  *         饿汉式（上来就new好对象）  vs  懒汉式(啥时候用啥是时候造）
  * 
  * 区分饿汉式和懒汉式
  *         饿汉式：坏处：对象加载时间过长。
  *                好处：饿汉式是线程安全的。
  * 
  *         懒汉式：好处：延迟对象的创建。
  *                目前的写法坏处：线程不安全。--->到多线程内容时，再修改
 
 
 
单例模式的优点：
 
 
单例模式的使用：
 
 
 

                 Java 关于单例模式(懒汉式与饿汉式的区别)
 
简单说下两个单例模式的不同点
 
懒汉式:
 
1.内部对象非final类型
 
2.线程安全
 
3.用到特定方法的时候才会实例化对象
 
饿汉式:
 
1.内部对象为final类型
 
2.在调用get方法之前,对象就已经实例化完毕
 
// 懒汉式
public class Singleton {
// 延迟加载保证多线程安全
    Private volatile static Singleton singleton;
    private Singleton(){}
    public static Singleton getInstance(){
        if(singleton == null){
            synchronized(Singleton.class){
                if(singleton == null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

// 饿汉式
class SingletonHungry{
    private final static SingletonHungry singletonHungry = new SingletonHungry();
    private SingletonHungry(){}
    // 务必使用static声明为类所属方法
    public static SingletonHungry getInstance(){
        return singletonHungry;
    }
}