单例设计模式

单例设计模式可以保证系统中应用该模式的类一个类只有一个实例，即保证一个类有且只有一个对象（实例）。它的好处是，单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。因为类控制了实例化过程，所以类可以灵活更改实例化过程。所有的内容的都是唯一的, 可以用作共享数据来用。
在Java语言中，单例模式的要点有3个：1、一个类只能有一个实例，2、它必须自行创建这个实例，3、它必须自行向整个系统提供这个实例。从具体实现角度来说，通常有两种构建方式，我们分别称为饿汉式和懒汉式。其中，懒汉式是线程不安全的，我们需要加上synchronize之类保证保证线程安全，这样就降低了程序的效率。

饿汉式：指全局的单例实例在类装载时构建。它的步骤是：
1.私有化构造
2.提供一个私有的静态的最终的本类对象
3.提供public static修饰的get方法获取本类对象
代码演示如下：

/**
 * 单例设计模式：保证一个类有且只有一个对象（实例）
 * 饿汉式：
 */
public class Student {

    //私有化构造函数，不让外界创建对象
    private Student(){}
    
    //提供一个私有的静态的最终的本类对象
    private static final Student student = new Student();
    
    //提供public static修饰的get方法获取本类对象
    public static Student getInstance(){
        return student;
    }
}

懒汉式：缺点是有线程安全问题，多条线程访问有可能产生多个对象，解决方案是加锁。它的步骤是：
1.私有化构造
2.提供一个公共的静态的最终的本类引用
3.提供公共的get方法返回对象, 返回之前判断是否为null
代码演示如下：

/**
 * 单例设计模式
 * 懒汉式：
 */
public class User {

    //私有化构造函数，不让外界创建对象
    private User(){}
    
    //提供一个公共的静态的最终本类引用
    private static User user;
    
    //返回本类对象，在返回之前需要判断对象是否创建
    //需要加锁保证线程安全，锁对象是User.class
    public synchronized static User getInstance(){
        if(user == null){
            user = new User();
        }
        return user;
    }
}

我们还有一种实现单例模式的方式，即程序员式。它的步骤是：
1.私有化构造
2.提供一个公共的静态的最终的本类对象
代码演示如下：

/**
 * 单例设计模式
 * 程序员式：
 */
public class Teacher {

    //私有化构造函数，不让外界创建对象
    private Teacher(){}
    
    //成员变量必须有对象才可以使用
    //提供一个公共的静态的最终的本类对象
    public final static Teacher teacher = new Teacher();

}

我们创建测试类进行测试，代码如下：

public class Test {
    public static void main(String[] args){
    
        //饿汉式
        for (int i = 0; i < 50; i++) {
            System.out.println(Student.getInstance());
        }
        
        //懒汉式
        for (int i = 0; i < 50; i++) {
            System.out.println(User.getInstance());
        }
        
        //程序员式
        for (int i = 0; i < 50; i++) {
            System.out.println(Teacher.teacher);
        }
    }
}

分别打印50次，会发现对象的地址值是相同的。

本文地址：https://blog.csdn.net/weixin_44180753/article/details/107394856