用Java简单实现单例模式

*Java实现单例模式

*单例模式是一种常用的设计模式，是23中设计模式中的一种。

*设计模式:设计模式是一种思想，是一种编程思想，是前人经验的累积。

*单例模式概念：在做某个项目中，创建了一个类，那么这个类只能生成一个对象。

*单例模式有两种实现方式分别：饿汉式和懒汉式

一.饿汉式

饿汉式：顾名思义，可以理解成一个饿汉，只要一加载类的时候就会创建了对象，因为用了static修饰，static修饰的成员随着类的加载而加载的

实现步骤：1：构造函数私有化

　　　　　2：提供一个静态对象属性用来接收对象

　　　　　3：创建一个静态方法用来获取对象实例

具体代码如下：

//那么怎么让这个类在整个项目中生成一个对象呢？使用单例模式
    //单例模式第一种：饿汉式
    //弊端：占用内存，如果我不想随着类的加载而加载，想延迟加载创建对象？需要用到懒汉式
    //为什么叫饿汉式呢？一加载类的时候就创建了对象，因为用了static修饰，static修饰的成员随着类的加载而加载
    //1.第一步：构造方法需要私有化
    //2.第二步：提供一个静态对象属性用来接收对象
    //3.第三步：提供一个静态方法用来获取对象
    //随着类的加载就马上创建了对象，很叽饿
    public static Single s=new Single();
    //私有的只能在本类中使用
    private Single(){}
    public static Single getSingle(){
        return s;
    }

二.懒汉式

懒汉式：比较懒的加载，不会随着类的加载而加载，而是在你调用创建对象实例的方法时才会创建对想

实现步骤：

第一步：构造方法需要私有化
第二步：提供一个静态属性
第三步：提供一个方法用来创建对象

代码实现如 :

 //懒汉式:顾名思义，这个是比较的懒的，在我们加载类的时候没有创建对象，而是在你调用了方法的时候才创建
    //第一步：构造方法需要私有化
    //第二步：提供一个静态属性
    //第三步：提供一个方法用来创建对象
    public static LazySingle lazySingle;
    private LazySingle(){}
    public static LazySingle getLazySingle(){
        //这里面需要创建对象
        //怎么解决？也就是说如何避免两个不同的线程创建不同的对象？
        //判断对象是否为空，为空进去创建，不为空就不能够创建
        //需要使用同步把生成的对象的相关代码锁起来（同步代码块或者同步方法都可以）
        // synchronized(锁对象) {}  LazySingle.class字节码对象
        //LazySingle加载到内存中去会编译成LazySingle.class文件，
        // 到JVM内存中，首先会加载到方法区，
        // 方法区中可能不止一个LazySingle.class文件，可能会有Dag.class,Cat.class...
        // 这样方法区中会存在很多的字节码文件，用面向对象的思维编写它，专门用一个类称呼它Class类
        //那么每一个字节码文件可以看成是一个字节码文件对象
//        Class<LazySingle> lazySingleClass = LazySingle.class;//Class类，Class类中的 LazySingle.class对象
        //还没有很完善，因为使用同步代码块会存在开锁和关锁的一个步骤，会降低执行效率，损耗时间
        //而且不同的线程去访问它的时候都要执行同步代码块，会降低执行效率，消耗时间
        //因为使用同步代码块会降低执行效率，消耗时间，为了避免减少使用同步代码块的一个次数
        //需要判断如果对象为空的时候才进入同步代码块
        //假如没有创建对象之前，两个不同的线程同时进入，那么所创建的对象也不一样
        // 就需要用同步代码块把生成对象的相关代码锁起来
        // 锁对象使用类的字节码对象 因为使用同步代码块会消耗时间
        // 为了避免减少使用同步代码块的次数，需要判断对象为空的时候，才进入同步代码块
        //这里是进行了双重检查 两个if判断
        if(lazySingle==null) {//如果不等于就不要创建，等于null创建 有利于提升执行效率
            synchronized (LazySingle.class) {//锁对象使用字节码对象
                //如何避免两个线程创建创建不同的对象
                //判断对象是否为空
                //判断对象是否为空，为空进去创建，不为空就不能够创建
                if (lazySingle == null) {
                    lazySingle = new LazySingle();
                }
            }
        }
        return lazySingle;
    }
    public void eat(){
        System.out.println("大口吃饭");
    }

三.创建测试类进行测试

代码如下：

 //饿汉式
        Single single = Single.getSingle();//创建两个对象
        Single single1 = single.getSingle();
        //如果返回true代表两个对象是同一个对象，反之则不是
        System.out.println(single==single1);//结果为true
        System.out.println(single);
        System.out.println(single1);
        //懒汉式
        LazySingle lazySingle = LazySingle.getLazySingle();
        LazySingle lazySingle1 = LazySingle.getLazySingle();
        //假如没有创建对象之前，两个不同的线程同时进入（发生的几率很小），那么所创建的对象也会不一样
        System.out.println(lazySingle==lazySingle1);//结果为true
        System.out.println(lazySingle);
        System.out.println(lazySingle1);

扩展：可以十一下把双重检查两个if判断去掉则会出现输出结果flase

不同线程去访问的时候，那么它们所创建的对象是不一样的
原因是什么？因为调用这个方法才去创建对象，相当去有一个线程去访问这个方法
为什么会出现false？不同线程去访问对象的时候，创建的对象是不一样的
图解如下：

 怎么解决？也就是说如何避免两个不同的线程创建不同的对象？加一个if判断，判断lazySingle == null是否为空，等于空就进入下面的代码，反正，则不进入。