文章目录

  • 概念
  • 实现的代码方式
  • 1.饿汉式代码实现
  • 2.懒汉式代码实现
  • 3.双层检查代码实现
  • 4.内部类的方式代码实现
  • 总结


概念

基本概念：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

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

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

注意：

1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。

实现的代码方式

1.饿汉
2.懒汉
3.双层检查
4.内部类

1.饿汉式代码实现

/**
 * @Author chenxintao
 * @Date 2022/10/25 17:15
 * @Version 1.0
 * 单例模式，保证全局唯一，即实例对象时只有一个入口，故私有构造方法
 * 饿汉模式，默认直接加载,线程安全，损耗较大
 */
public class Singleton {

    public static Singleton singleton = new Singleton();

    private Singleton(){}

    public static Singleton getInstance(){
        return singleton;
    }

    public void method(){
        System.out.println("使用了饿汉模式，直接加载");
    }

    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance);
        System.out.println(instance1);
        instance.method();
        instance1.method();
    }
}

2.懒汉式代码实现

/**
 * @Author chenxintao
 * @Date 2022/10/25 17:26
 * @Version 1.0
 * 单例模式，保证全局唯一，即实例对象时只有一个入口，故私有构造方法
    优点：延迟加载（需要的时候才去加载）,适合单线程操作
    缺点： 线程不安全，在多线程中很容易出现不同步的情况，如在数据库对象进行的频繁读写操作时,不可使用
 */
public class LazySingleton {

    /* 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载 */
    private static LazySingleton instance = null;

    /* 私有构造方法，防止被实例化 */
    private LazySingleton(){}

    /** 延迟加载 */
    public static LazySingleton getInstance() {
        if (instance == null){
            instance = new LazySingleton();
        }
        return instance;
    }

    protected void method() {
        System.out.println("饿汉模式，懒加载。。");
    }
}

3.双层检查代码实现

/**
 * @Author chenxintao
 * @Date 2022/10/25 17:34
 * @Version 1.0
 * 单例模式，保证全局唯一，即实例对象时只有一个入口，故私有构造方法
 * 优点：线程安全，支持延时加载，调用效率高
 * 缺点： 写法复杂，不简洁
 * 在饿汉的模式下增强
 */
public class DoubleCheckSingleton {

    private static DoubleCheckSingleton instance = null;

    private DoubleCheckSingleton(){}

    protected static DoubleCheckSingleton getInstance(){
        if (instance == null){
            synchronized (DoubleCheckSingleton.class){
                if (instance == null){
                    instance = new DoubleCheckSingleton();
                }
            }
        }
        return instance;
    }

    public void method(){
        System.out.println("使用了加锁双层检查模式，懒加载");
    }

    public static void main(String[] args) {
        DoubleCheckSingleton.getInstance().method();
    }
}

4.内部类的方式代码实现

/**
 * @Author chenxintao
 * @Date 2022/10/25 17:46
 * @Version 1.0
 *  单例模式，保证全局唯一，即实例对象时只有一个入口，故私有构造方法
 *  优点：延迟加载，线程安全（java中class加载时互斥的），也减少了内存消耗，推荐使用内部类方式。
 */
public class SingletonInner {
    /**
     * 内部类实现单例模式
     * 延迟加载，减少内存开销
     */
    private static class SingletonHolder {
        private static SingletonInner instance = new SingletonInner();
    }

    private SingletonInner() {}

    private static SingletonInner getInstance(){
        return SingletonHolder.instance;
    }

    public void method(){
        System.out.println("使用内部类的模式，延迟加载");
    }
}

总结

最优解是内部类的方式，次优解是双层检查模式，懒汉式请不要使用。