Java-单例模式的几种写法

最新推荐文章于 2025-06-01 22:43:27 发布

原创最新推荐文章于 2025-06-01 22:43:27 发布 · 置顶 · 5.9k 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#java #设计模式 #基础

java 同时被 3 个专栏收录

22 篇文章

订阅专栏

设计模式

5 篇文章

订阅专栏

java基础

4 篇文章

订阅专栏

本文探讨了Java中实现单例模式的几种常见方法，包括饿汉式、线程不安全的饿汉式、懒汉式、双重检查懒汉式以及静态内部类方式。总结了每种方式的优缺点，如线程安全、懒加载和性能影响，并推荐了静态内部类方式作为高效且安全的选择。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一，饿汉式

优点：线程安全，实现简单。

缺点：类加载时就初始化了，没有实现懒加载。

public final class HungrySingleTon {

    private static final HungrySingleTon instance = new HungrySingleTon();

    private HungrySingleTon() {
        if (instance != null) {
            throw new IllegalStateException("实例已经初始化！");
        }
    }

    public HungrySingleTon getInstance() {
        return instance;
    }
}

二，饿汉式（线程不安全的形式）

优点：懒加载。

缺点：线程不安全。

public final class SingleTonSecond {

    private static SingleTonSecond singleTonSecond;

    private SingleTonSecond() {
        if (singleTonSecond!= null) {
            throw new IllegalStateException("实例已经初始化！");
        }
    }

    public static SingleTonSecond getInstance() {
        if (null == singleTonSecond) {
            singleTonSecond = new SingleTonSecond();
        }
        return singleTonSecond;
    }
}

三、懒汉式（线程安全）

优点：懒加载、线程安全。

缺点：每次获取单例都要锁定整个方法，性能较差

public final class LazySingleTonSafe {

    private static volatile LazySingleTonSafe instance;

    private LazySingleTonSafe() {
        if (instance != null) {
            throw new IllegalStateException("实例已经初始化！");
        }
    }

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

四、双重检查懒汉式单例

优点：线程安全，只在第一次获取单例时锁定了单例对象。

public final class DoubleCheckedLockSingleTon {

    private static volatile DoubleCheckedLockSingleTon instance;

    private DoubleCheckedLockSingleTon() {
        if (instance != null) {
            throw new IllegalStateException("实例已经初始化！");
        }
    }

    public static DoubleCheckedLockSingleTon getInstance() {

        if (null == instance) {
            synchronized (DoubleCheckedLockSingleTon.class) {
                if (null == instance) {
                    instance = new DoubleCheckedLockSingleTon();
                }
            }
        }
        return instance;
    }
}

五、静态内部类方式-推荐！

优点：线程安全，懒加载，效率高静态内部类的凡是在单例类在被JVM加载到内存时并不会立即实例化，而是在第一次调用的getInstance（）方法时才会将SingleTonFifthInner类加载到内存，从而实例化SingleTonFifthInner的静态属性。JVM在类加载阶段是同步加锁的，因此JVM替我们保证了在同一时刻只会有一个内部类被加载。

public final class StaticInnerClassSingleTon {

    private StaticInnerClassSingleTon() {

    }

    private StaticInnerClassSingleTon getInstance() {
        return StaticInnerClassSingleTonHolder.instance;
    }

    private static class StaticInnerClassSingleTonHolder {

        private static final StaticInnerClassSingleTon instance = new StaticInnerClassSingleTon();
    }

}

六，枚举类型实现单例模式

public class SingleTonSixth {

    private SingleTonSixth(){

    }

    public static SingleTonSixth getInstance(){
        return SingleTonEnum.ISNTANCE.getInstancee();
    }

    private static enum SingleTonEnum{
        ISNTANCE;

        private  SingleTonSixth singleTonSixth;

        private  SingleTonEnum(){
            singleTonSixth=new SingleTonSixth();
        }

        private  SingleTonSixth getInstancee(){
            return singleTonSixth;
        }

    }
}