Java单例模式实现与对象唯一保障

学习文章要努力，但是不要急！今天的这篇文章《Java单例模式实现及对象唯一保障方法》将会介绍到等等知识点，如果你想深入学习文章，可以关注我！我会持续更新相关文章的，希望对大家都能有所帮助！

饿汉式在类加载时创建实例，线程安全但不支持懒加载；2. 懒汉式在首次调用时创建实例，支持懒加载但线程不安全；3. 线程安全的懒汉式通过synchronized实现线程安全和懒加载，但性能较低；4. 双重检查锁通过volatile和同步块实现高效线程安全与懒加载，实现较复杂；5. 静态内部类利用类加载机制实现线程安全和懒加载，推荐使用；6. 枚举实现线程安全且防止反射和序列化攻击，但不支持懒加载；防御反射攻击可在构造方法中检查实例是否存在并抛出异常，枚举单例天然防止反射攻击；单例模式通过类加载机制或同步手段保证多线程环境下的线程安全；单例模式限制一个类仅有一个实例并提供全局访问点，而工厂模式封装对象创建过程，两者关注点不同，单例控制实例数量，工厂抽象创建逻辑，工厂模式可创建单例对象，但二者本质不同，完整结束。

Java单例模式的核心在于确保一个类只有一个实例，并提供一个全局访问点。实现这一点，需要控制类的实例化过程。

解决方案

Java中实现单例模式有多种方法，各有优劣，选择哪种取决于具体场景的需求，比如是否需要懒加载、线程安全等。

1. 饿汉式（Eager Initialization）

这是最简单的实现方式，在类加载时就完成了实例化。

public class Singleton {
    private static final Singleton instance = new Singleton();

    private Singleton() {
        // 私有构造方法，防止外部实例化
    }

    public static Singleton getInstance() {
        return instance;
    }

    public void doSomething() {
        System.out.println("Singleton is doing something...");
    }
}

• 优点： 实现简单，线程安全（因为在类加载时完成实例化）。
• 缺点： 不是懒加载，如果单例对象一直没有被用到，会造成资源浪费。

2. 懒汉式（Lazy Initialization）

在第一次调用getInstance()方法时才进行实例化。

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // 私有构造方法，防止外部实例化
    }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

    public void doSomething() {
        System.out.println("Singleton is doing something...");
    }
}

• 优点： 实现了懒加载，只有在需要的时候才会创建实例。
• 缺点： 线程不安全，在多线程环境下可能会创建多个实例。

3. 线程安全的懒汉式（Synchronized Lazy Initialization）

为了解决懒汉式的线程安全问题，可以对getInstance()方法进行同步。

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // 私有构造方法，防止外部实例化
    }

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

    public void doSomething() {
        System.out.println("Singleton is doing something...");
    }
}

• 优点： 线程安全，实现了懒加载。
• 缺点： 效率较低，每次调用getInstance()方法都需要进行同步，开销较大。

4. 双重检查锁（Double-Checked Locking）

一种更高效的线程安全懒汉式实现。

public class Singleton {
    private volatile static Singleton instance;

    private Singleton() {
        // 私有构造方法，防止外部实例化
    }

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

    public void doSomething() {
        System.out.println("Singleton is doing something...");
    }
}

• 优点： 线程安全，实现了懒加载，效率较高。
• 缺点： 实现较为复杂，需要注意volatile关键字的使用，防止指令重排序导致的问题。

5. 静态内部类（Static Inner Class）

利用类加载机制保证线程安全和懒加载。

public class Singleton {
    private Singleton() {
        // 私有构造方法，防止外部实例化
    }

    private static class SingletonHolder {
        private static final Singleton instance = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }

    public void doSomething() {
        System.out.println("Singleton is doing something...");
    }
}

• 优点： 线程安全，实现了懒加载，实现简单，推荐使用。
• 缺点： 无。

6. 枚举（Enum）

最简洁的实现方式，可以防止反射攻击和序列化问题。

public enum Singleton {
    INSTANCE;

    public void doSomething() {
        System.out.println("Singleton is doing something...");
    }
}

• 优点： 线程安全，防止反射攻击和序列化问题，实现简单。
• 缺点： 不能懒加载。

单例模式中的反射攻击如何防御？

反射机制允许在运行时检查和修改类的行为。对于单例模式，这意味着可以通过反射创建多个实例，破坏单例的特性。防御反射攻击的主要方法是在构造方法中进行检查，如果已经存在实例，则抛出异常。例如：

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        if (instance != null) {
            throw new IllegalStateException("Singleton instance already exists.");
        }
    }

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

这样，即使通过反射调用构造方法，也会因为抛出异常而无法创建新的实例。枚举单例天然防止反射攻击，因为Java语言规范禁止通过反射创建枚举实例。

单例模式在多线程环境下如何保证线程安全？

多线程环境是单例模式需要重点考虑的场景。线程安全意味着在多个线程同时访问单例对象时，不会出现数据不一致或者创建多个实例的情况。上述的几种实现方式中，饿汉式、静态内部类和枚举天生就是线程安全的。懒汉式需要进行同步处理，才能保证线程安全。双重检查锁是一种常用的优化手段，可以减少同步的开销。

单例模式与工厂模式的区别是什么？

单例模式和工厂模式是两种不同的设计模式，虽然它们都涉及到对象的创建，但解决的问题和应用场景不同。单例模式关注的是如何保证一个类只有一个实例，并提供全局访问点。工厂模式关注的是如何将对象的创建过程封装起来，使得客户端不需要知道具体类的创建细节。简单来说，单例模式是限制类的实例化数量，而工厂模式是抽象类的实例化过程。工厂模式可以创建单例对象，但单例模式不一定需要通过工厂模式来创建。

本篇关于《Java单例模式实现与对象唯一保障》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于文章的相关知识，请关注golang学习网公众号！