1、饿汉式: 在加载类的同时，就要初始化静态成员变量，所以就同时将该类对象创建出来了

   代码举例:

     

class SingletonHungry {

//私有化构造方法

private SingletonHungry() {

}

//在类中声明该类型的引用，并且创建对象

private static SingletonHungry sh = new SingletonHungry();

//给外界提供获取对象的方式

public static SingletonHungry getInstance() {

return sh;

}

}

2、懒汉式: 在加载类的时候，不同时创建该类对象，等到需要获取这个对象时，才去创建这个对象,不着急、能不创建的时候，就不创建，能拖就拖

代码举例:

  

class SingletonLazy {

//构造方法私有化

private SingletonLazy() {

}

//声明一个该类型的引用;

private static SingletonLazy sl;

//提供获取对象的方法

public static SingletonLazy getInstance() {

//提升效率的判断，后期大部分sl都不为null，不需要再获取锁对象，浪费时间

//即使在此判断了sl为null，也不能保证确实为null，内层还有更精确更浪费时间的判断

//如果再次判断了sl不为null，那么一定不为null，就不需要再浪费时间判断了

if (sl == null) {

synchronized (SingletonLazy.class) {//不想让sl的判断，和sl的赋值分离开，否则会出现数据的判断错误

if (sl == null) {//在即将创建对象的前一瞬间，判断是否应该创建对象，此处的判断确保正确

sl = new SingletonLazy();

}

}

}

return sl;

}

}

 

饿汉是在加载类的时候，该类的对象就已经被创建了，懒汉是在使用该类对象的时候，才去创建对象

单例模式懒汉式和饿汉式区别

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

 

注意：

1、单例类只能有一个实例。

2、单例类必须自己创建自己的唯一实例。

3、单例类必须给所有其他对象提供这一实例。

明确定义后，看一下代码：

饿汉式

public class SingletonEH {

    /**

     *是否 Lazy 初始化：否

     *是否多线程安全：是

     *实现难度：易

     *描述：这种方式比较常用，但容易产生垃圾对象。

     *优点：没有加锁，执行效率会提高。

     *缺点：类加载时就初始化，浪费内存。

     *它基于 classloder 机制避免了多线程的同步问题，

     * 不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，

    * 在单例模式中大多数都是调用 getInstance 方法，

     * 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，

     * 这时候初始化 instance 显然没有达到 lazy loading 的效果。

     */

    private static SingletonEH instance = new SingletonEH();

    private SingletonEH (){}

    public static SingletonEH getInstance() {

        System.out.println("instance:"+instance);

        System.out.println("加载饿汉式....");

        return instance;

    }

}

 

饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了。

懒汉式

public class SingletonLH {

    /**

     *是否 Lazy 初始化：是

     *是否多线程安全：否

     *实现难度：易

     *描述：这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。

     *这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。

     */

    private static SingletonLH instance;

    private SingletonLH (){}

 

    public static SingletonLH getInstance() {

        if (instance == null) {

            instance = new SingletonLH();

        }

        return instance;

    }

}

而懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例。

饿汉式:
        public class Singleton{
            private static Singleton singleton = new Singleton ();
            private Singleton (){}
            public Singleton getInstance(){return singletion;}
       } 

     懒汉式:
       public class Singleton{
            private static Singleton singleton = null;
            public static synchronized synchronized getInstance(){
                 if(singleton==null){
                     singleton = new Singleton();
                 }
                return singleton;
            }
       } 

     比较:
         饿汉式是线程安全的,在类创建的同时就已经创建好一个静态的对象供系统使用,以后不在改变
          懒汉式如果在创建实例对象时不加上synchronized则会导致对对象的访问不是线程安全的
          推荐使用第一种