java 单例模式实现的5种方式

最新推荐文章于 2024-09-29 20:18:52 发布

清茶煮酒.

最新推荐文章于 2024-09-29 20:18:52 发布

阅读量1.7k

点赞数 1

文章标签： java 单例模式

本文链接：https://blog.csdn.net/qq_49983016/article/details/124129182

版权

本文详细介绍了Java中实现单例模式的五种常见方法：饿汉式、懒汉式、双检锁式、静态内部类式和枚举类型。每种方式都有其特点，如饿汉式确保线程安全但牺牲了空间效率，懒汉式延迟初始化但不保证线程安全，双检锁式在保证线程安全的同时延迟初始化，静态内部类式利用类加载机制保证单例，而枚举类型是最简洁且线程安全的实现方式。这些方法对于理解和实践Java并发编程的单例模式具有重要意义。

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

第一种：饿汉式

/**
 * Created with IntelliJ IDEA.
 *
 * @author: 宸濯
 * Date: 2021/08/18 8:21
 * Description:单例模式的设计(饿汉式)
 * 1.构造方法私有化
 * 2.在静态语句块实例化
 * 3.提供调用实例对象的方法
 * 4.空间换时间，不管有没有调用方法，实例都创建了
 * Version: V1.0
 */
public class SingletonOne {

    private static final int THREADS=100;
    private static SingletonOne instance;
    /**
     * 构造方法私有化
     */
    private SingletonOne(){}

    static {
        instance=new SingletonOne();
    }

    public static SingletonOne getInstance(){
        return instance;
    }

    public static void main(String[] args) {
        for (int i=0;i<THREADS;i++){
            new Thread(
                    ()-> System.out.println(getInstance().hashCode())
            ).start();
        }
    }
}

第二种：懒汉式

/**
 * Created with IntelliJ IDEA.
 * @author: 宸濯
 * Description:单例模式设计(懒汉式)
 * 1.构造方法私有化
 * 2.在调用时判断是否实例化
 * 3.时间换空间，调用方法时创建实例对象
 */
public class SingletonTow {

    private static SingletonTow instance;
    private static final int THREADS=100;
    private SingletonTow(){}

    public static SingletonTow getInstance(){

        if (instance==null){
            instance=new SingletonTow();
        }
        return instance;
    }

    public static void main(String[] args) {
        for (int i=0;i<THREADS;i++){
            new Thread(
                    ()-> System.out.println(getInstance().hashCode())
            ).start();
        }
    }
}

第三种：双检锁式

/**
 * Created with IntelliJ IDEA.
 * @author: 宸濯
 * Description:单例模式设计(双检锁懒汉式)
 * 1.构造方法私有化
 * 2.在调用时判断是否实例化
 * 3.时间换空间，调用方法时创建实例对象
 */
public class SingletonTow {
    /**
     * volatile修饰符防止指令重排序
     */
    private static volatile SingletonTow instance;
    private static final int THREADS=100;
    private SingletonTow(){}

    public static SingletonTow getInstance(){

        if (instance==null){
            synchronized (SingletonTow.class){
                //双重判定，防止高并发，不过会导致指令重排序
                if (instance==null){
                    instance=new SingletonTow();
                }
            }
        }
        return instance;
    }

    public static void main(String[] args) {
        for (int i=0;i<THREADS;i++){
            new Thread(
                    ()-> System.out.println(getInstance().hashCode())
            ).start();
        }
    }
}

java并发编程：volatile关键字解析

第四种：静态内部类式

/**
 * Created with IntelliJ IDEA.
 *
 * @author: 宸濯
 * Description:设计单例模式
 * 1.构造方法私有化
 * 2.静态内部类实例化对象
 * 3.静态内部类只会被加载一次，类加载的初始化阶段是单线程的，没有高并发带来的冲突
 */
public class SingletonThree {

    /**
     * 声明线程数
     */
    private static final int THREADS=100;
    private static class Inner{
        private static final SingletonThree INSTANCE=new SingletonThree();
    }

    private SingletonThree(){}

    public static SingletonThree getInstance(){
        return Inner.INSTANCE;
    }

    public static void main(String[] args) {
        for (int i=0;i<THREADS;i++){
            new Thread(
                    ()-> System.out.println(SingletonThree.getInstance().hashCode())
            ).start();
        }
    }
}

第五种：枚举类型

/**
 * Created with IntelliJ IDEA.
 * @author : 宸濯
 */
public enum  SingletonFour {

    //枚举类型设计单例模式
    SINGLETON_FOUR;

    public void test(){
        System.out.println("hello world");
    }

}

public class Main {
    public static void main(String[] args) {
        SingletonFour.SINGLETON_FOUR.test();
    }
}