设计模式---单例模式

所谓单例，即使单一的实例，就是要保证对象只有一个。

单例模式：单一的实例，保证类在内存中的只有一个对象。
举例：windows的打印服务，网站计数器
java的应用：Runtime

2.如何保证类在内存中只有一个对象？

A：把构造器方法私有，为了不让外界创建对象
B：在类中去创建一个对象
C：通过一个公共的访问方式给外界提供一个入口

单例模式，分饿汉式或懒汉式。

下面请看饿汉式

package cn.itcast_singleton;

public class Student {
    //为了不让外界访问，我们把构造器方法私有
    private Student(){};
    

    //创建一个对象
    //为了满足静态方法访问，这里必须加一个静态修饰符
    //为了不让外界修改s对象，加私有修饰
    private static Student s=new Student();
    
    //提供一个公共的访问方式
    //为了让外界直接访问，我们就给方法添加一个静态修饰符
    
    public static Student getStudent(){
            return s;
    }
    
    public void show(){
        
        System.out.println("i love java");
    }

}


package cn.itcast_singleton;

public class StudentTest {
    public static void main(String[] args){
//        Student s1=new Student();
//        Student s2=new Student();
//        System.out.println(s1==s2);
        
        //由于成员变量是被静态修饰的，所以外界也可以通过类名访问
        //Student.s=null;
        
        
        
        //通过单利模式获取对象并调用方法
        Student s1=Student.getStudent();
        Student s2=Student.getStudent();
        System.out.println(s1==s2);
        s1.show();
        s2.show();
        
    }
}

再看懒汉式

懒汉式单例模式：
延迟加载思想：我们什么时候需要对象，你什么时候给我对象就可以了。(Hibernate，Spring)
第一次访问的时候去创建，，第二次去访问是不创建的

package cn.itcast_singleton;

public class Teacher {
    //为了不让外界创建对象，把构造方法私有
    private Teacher(){}
    //本来创建一个对象
    //加static 是为了保证静态方法可以访问
    //夹private是为了保证外界不能直接访问
    
    private static Teacher t=null;
    
    //提供公共访问的方式
    public  static Teacher getTeacher(){
        //比如说我有t1和t2同时来访问，那么，这个时候，
        //当t1进来后，判断这个t是null，
        //所以，t1就进去执行if所控制的语句
        //但是注意了，由于线程的随机性，可能t1刚进去要执行if所控制的语句
        //这个时候，被t2抢到的CPU的执行权，者古时候，t2就开始执行了
        //发现，这个时候还是null，所以，t2也进去执行if所控制的语句了
        //那么，会有多个对象被创建
        
        //Runtime
        
        
        
        
        
        
        
        if(t==null){
            t=new Teacher();
        }
        
        return t;
    }
    
    //写了一个方法
    public void  show(){
        
        System.out.println("老师爱林青霞");
    }
    
    
    

}


package cn.itcast_singleton;

public class TeacherTest {
    public static void main(String[] args) {
//        Teacher t1=new Teacher();
//        Teacher t2=new Teacher();
        
        Teacher t1=Teacher.getTeacher();
        Teacher t2=Teacher.getTeacher();
        
        t1.show();
        t2.show();
        
    }

}

那么，我们在开发中到底用到谁呢？

一般我们开发中采用第一种方案也就是饿汉式

原因：
前提：多线程安全问题

面试的时候，会面试懒汉式。
并且请注意，面试懒汉式主要是面试一下几个问题：
A：延迟加载思想   啥时用，啥时再创建
B：线程安全
      a.线程安全问题是怎么产生的。
   b.现在安全问题是怎么解决的。

6：其实在JDK提供的类中，已经有单例模式的应用，是谁呢？Runtime类
从这个类的源码中，可以看出
开发中用的是饿汉式