[设计模式]单例设计模式

1:单例模式(面试)

单例模式:单一的实例.保证类在内存中只有一个对象.
举例:

①windows的打印费服务.网站的计数器.(如果一个网站统计访问量有多个计数器,就会有问题.)
②Java中的应用:数据库连接池,Runtime这个类.

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

A:把构造方法私有,为了不让外界创建对象.
B:在类中创建 一个对象.(有一个对象,还是要创建它)
C:通过一个公共的访问方式,给外界一个入口.(否则外界根本就无法访问到)

3.饿汉式单例模式:

Student.java

public class Student {
    //为了不让外界访问,我们把构造方法私有.
    private Student(){
        
    }
    //创建一个对象
    //为了满足静态方法访问,这里也必须加一个静态修饰符static(暂时先不加private,慢慢引入private)
    //static Student s = new Student();
    private static Student s = new Student();
    
    //提供一个公共的访问方式
    //(访问这个方法可以通过Student类的对象,但是构造方法私有化了无法让外界访问)
    //所以为了让外界直接访问,只能让这个方法静态.
    public static Student getStudent(){
        //比如说我有t1和t2同时来访问,那么这个时候.拿的都是上面new的
        return s;
        //如果此时上面的Student s = new Student();不用静态修饰,报错.内容如下
        //Cannot make a static reference to the non-static field s
        //一个静态的上下文,不能有一个非静态的变量.
        //所以为了满足静态方法访问,new Student的时候必须用static修饰.
    }
    
    public void show(){
        System.out.println("我爱java");
    }
}

测试类:StudentTest.java

public class StudentTest {
    public static void main(String[] args) {
        /*
        Student s1 = new Student();
        Student s2 = new Student();
        System.out.println(s1 == s2);//false
        */
        //由于成员变量是被静态static修饰的,前面没有加访问修饰符,默认是default外界也可以通过类名访问的.
        //Student.s = null;
        //这样的话下面运行s1.show()的时候就会报java.lang.NullPointerException
        //为了不让外界访问s,就再在new 的时用private修饰. 这样此时
                    
        //通过单例模式获取对象并调用方法.
        
        Student s1 = Student.getStudent();
        Student s2 = Student.getStudent();
        System.out.println(s1 == s2);//true
        
        s1.show();
        s2.show();
    }
}

4:懒汉式单例模式(想用的时候再用)

懒汉式有一个非常重要的思想----延迟加载思想.
我们什么时候需要,你就什么时候给. 这个思想在Hibernate和Spring中都用了这个思想.  特别是Hibernate框架中的lazy....

Teacher.java

public class Teacher {
    // 为了不让外界创建对象,把构造方法私有.
    private Teacher() {
    }

    // 本类创建一个对象.
    // 加static是为了保证静态方法可以访问.
    // 加private是为了保证外界不能直接访问
    private static Teacher t = null;

    // 提供公共的访问方式.
    //synchronized是为了解决懒汉式多线程不安全加上的.
    //被同步的代码,在某一时刻只能被一个线程访问.
    public synchronized static Teacher getTeacher() {
                /*
                比如说我有t1和t2同时来访问,那么这个时候.
                当t1进来后,判断这个时候t是null
                所以,t1就进去执行if所控制的语句.
                但是注意了,由于线程的随机性.可能当t1刚进去要执行if说控制的语句.
                发现,这个时候t还是null,所以,t2也去执行if所控制的语句了.
                那么将来就会有多个对象被创建.
                */
        // 当外界需要使用它,就在这里new一个.
        if (t == null) {
            // 只有第一次访问这里的时候才进入if语句new一个对象.
            // 第二次的时候因为第一次已经new了一个Teacher,并且Teacher是用static修饰
            // static修饰的是共享的.有值了,就不再进入if了.
            t = new Teacher();
        }
        return t;
    }

    // 写了一个方法
    public void love() {
        System.out.println("老师爱学生");
    }
}

TeacherTest.java

public class TeacherTest {
    public static void main(String[] args) {
        Teacher t1 = Teacher.getTeacher();
        Teacher t2 = Teacher.getTeacher();
        System.out.println(t1 == t2);// true

        t1.love();
        t2.love();
    }
}

5:那么我们在开发中到底使用谁呢?

一般开发中使用第一种方案(饿汉式)
原因是:
前提:多线程安全问题.
面试的时候会面试懒汉式. 并且,请注意,面试懒汉式,主要是面试下面几个问题:
A:延迟加载思想.
B:线程安全问题.
a:线程安全问题是怎么产生的.
b:线程安全问题是怎么解决的.

6:其实在JDK中提供的类中,已经有单例模式的应用.是谁呢?Runtime类.

附上JDK中关于Runtime类的源码:

Runtime.java

public class Runtime {
    //这就是一个饿汉式的应用.
    private static Runtime currentRuntime = new Runtime();
    
    public static Runtime getRuntime() { 
        return currentRuntime;
    }
    
    private Runtime() {}        
        
}