设计模式之单例模式

最新推荐文章于 2024-07-31 10:46:54 发布

飞天蝙蝠柯大侠

最新推荐文章于 2024-07-31 10:46:54 发布

阅读量57

点赞数

分类专栏：设计模式

本文链接：https://blog.csdn.net/a1286160028/article/details/118662910

版权

设计模式专栏收录该内容

5 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中实现单例模式的六种方法，包括懒汉式、线程安全的懒汉式、双重校验锁、饿汉式、内部类和枚举实现。每种方式都有其优缺点，如线程安全性、懒加载和性能考虑。其中，枚举实现被认为是最简洁且防止序列化破坏单例的方式。

摘要由CSDN通过智能技术生成

单例模式是一种创建型模式，单例类只允许有一个实例。

1.懒汉式，线程不安全

/**
 * 懒汉式 线程不安全
 */
class Singleton1{
    private static  Singleton1 instance;
    private Singleton1(){}
    public static Singleton1 getInstance(){
        if(instance == null){
            instance = new Singleton1();
        }
        return instance;
    }
}

2.懒汉式，线程安全

/**
 * 懒汉式 线程安全
 */
class Singleton2{
    private static  Singleton2 instance;
    private Singleton2(){}

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

相比第一种实现方式，该方式在获取实例的方法上加上了synchronized关键字

3.双重校验（懒加载、线程安全）


/**
 * 双重校验锁（懒加载、线程安全）
 */
class Singleton3{
    private static Singleton3 instance;
    private Singleton3(){};
    public static Singleton3 getInstance(){
        if(instance == null){
            synchronized (Singleton3.class){
                if(instance == null){
                    instance=new Singleton3();
                }
            }
        }
        return instance;
    }
}

这个版本较之上个版本性能更好，不用每次获取实例都要获取锁，双重校验避免重复创建实例。

4.饿汉式（非懒加载，线程安全）

/**
 * 饿汉式（非懒加载，线程安全）
 */
class Singleton4{
    private static Singleton4 instance = new Singleton4();
    private Singleton4(){};

    public static Singleton4 getInstance(){
        return instance;
    }
}

5.内部类实现（懒加载，线程安全）

/**
 * 内部类（懒加载，线程安全）
 */
class Singleton5{
    private Singleton5(){};
    private static final class SingletonInner{
        private static final Singleton5 INSTANCE = new Singleton5();
    }

    public static final Singleton5 getInstance(){
        return SingletonInner.INSTANCE;
    }
}

6.枚举实现（非懒加载，线程安全）

/**
 * 枚举（非懒加载，线程安全）
 */
enum Singleton6{
    INSTANCE;
    public void fun1(){
        System.out.println("嘿嘿嘿");
    }
}


public static void main(String[] args) {
        Singleton6.INSTANCE.fun1();
}

枚举实现是最简单最好的实现单例模式的方式，值得一提的是它天然的可以防止序列化所造成的实例不唯一的问题。