java单例实现

最新推荐文章于 2025-04-08 16:23:55 发布

Coco_淳

最新推荐文章于 2025-04-08 16:23:55 发布

阅读量158

点赞数

分类专栏：设计模式文章标签： java 单例模式开发语言

本文链接：https://blog.csdn.net/Coco_chun/article/details/124706775

版权

设计模式专栏收录该内容

1 篇文章

订阅专栏

本文详细介绍了Java中实现单例设计模式的五种常见方式：饿汉模式、双重检查锁、静态内部类、静态代码块以及通过枚举。每种方式都有其特点和适用场景，例如饿汉模式的线程安全但初始化较早，枚举方式则兼顾了线程安全和防止反序列化破坏单例等。

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

参考链接：2021-11-13 枚举、Enum中的常用类、Enum中添加新方法、switch语句中的Enum、Enum静态导入、枚举实现单例设计模式_轩轩Aminent的博客-CSDN博客

参考链接：Java实现单例的5种方式_scuwangjun的博客-CSDN博客_java单例

package org.example;

import java.io.*;

/**
 * @author coco
 * @date 2022/5/11
 */
//饿汉模式
public class Singleton {

    private Singleton(){};

    private static Singleton singleton = new Singleton();

    public static Singleton getInstance(){
        return singleton;
    }
}
//双重检查锁
public class Singleton {

    private Singleton(){};

    private static volatile Singleton singleton;

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

 //静态内部类
public class Singleton {

    private Singleton(){};

    private static class inner{
        private static Singleton singleton = new Singleton();
    }

    public static Singleton getInstance(){
        return inner.singleton;
    }
}
//静态代码块
public class Singleton {

    private Singleton(){};

    private static Singleton singleton ;

    static{
        singleton = new Singleton();
    }

    public static Singleton getInstance(){
        return singleton;
    }
}

//序列化与反序列化
public class Singleton{

    public static void main(String[] args) {
        try {
            SingletonStaticInnerSerialize serialize = SingletonStaticInnerSerialize.getInstance();
            System.out.println(serialize.hashCode());
            //序列化
            FileOutputStream fo = new FileOutputStream("tem");
            ObjectOutputStream oo = new ObjectOutputStream(fo);
            oo.writeObject(serialize);
            oo.close();
            fo.close();
            //反序列化
            FileInputStream fi = new FileInputStream("tem");
            ObjectInputStream oi = new ObjectInputStream(fi);
            SingletonStaticInnerSerialize serialize2 = (SingletonStaticInnerSerialize) oi.readObject();
            oi.close();
            fi.close();
            System.out.println(serialize2.hashCode());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}



class SingletonStaticInnerSerialize implements Serializable {


    private static final long serialVersionUID = 1L;

    private static class InnerClass {
        private static SingletonStaticInnerSerialize singletonStaticInnerSerialize = new SingletonStaticInnerSerialize();
    }

    public static SingletonStaticInnerSerialize getInstance() {
        return InnerClass.singletonStaticInnerSerialize;
    }

	protected Object readResolve() {
		System.out.println("调用了readResolve方法");
		return InnerClass.singletonStaticInnerSerialize;
	}
}

//枚举实现单例
public class Singleton{
    private Singleton(){}

    private enum SingletonHolder{
        INSTANT;
        private final Singleton instant;
        SingletonHolder(){
            instant = new Singleton();
        }
    }

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

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