设计模式——单例模式

本文详细介绍了Java中实现单例模式的五种方式:饿汉式(静态常量法和静态代码块)、懒汉式(同步方法和双重检查)、静态内部类。每种方式都附带了代码示例和执行结果,并分析了各自的优缺点,包括内存使用和线程安全性。
摘要由CSDN通过智能技术生成

定义:

采取一定的方法保证在整个的软件系统中,对某个类只能存在一个对象实例


饿汉式(静态常量法)

/**
 * @create fanzixia 实体类
 * @time 2022/4/25 23:16
 */
public class SingletonHungry {
    //构造器私有化
    private SingletonHungry() {
    }
    //本类内部创建对象实例
    private final static SingletonHungry instance = new SingletonHungry();
    //提供一个公有的静态方法,返回实例对象
    public static SingletonHungry getInstance() {
        return instance;
    }
}

/**
 * @create fanzixia 调用方法类
 * @time 2022/4/25 23:13
 */
public class SingletonTest {

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

}

执行结果

 

优缺点:

  1. 写法简单,类加载时完成对象创建,线程安全
  2. 可能造成内存浪费:已实例化的对象可能一直不被调用

饿汉式(静态代码块) 

/**
 * @create fanzixia 实体类
 * @time 2022/4/25 23:13
 */
public class SingletonHungry2 {
    //构造器私有化
    private SingletonHungry2() {
    }
    private static SingletonHungry2 instance;
    //在静态代码块中完成对象创建
    static {
        instance = new SingletonHungry2();
    }
    //提供一个公有的静态方法,返回实例对象
    public static SingletonHungry2 getInstance() {
        return instance;
    }
}

/**
 * @create fanzixia 调用方法类
 * @time 2022/4/25 23:16
 */
public class SingletonTest {

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

}

 执行结果

优缺点:

  1. 写法简单,类加载时完成对象创建,线程安全
  2. 可能造成内存浪费:已实例化的对象可能一直不被调用

懒汉式(同步方法) 

/**
 * @create fanzixia 实体类
 * @time 2022/4/25 23:13
 */
public class SingletonHungry3 {
    //构造器私有化
    private SingletonHungry3() {
    }
    private static SingletonHungry3 instance;
    //提供一个静态的公有方法,加入同步处理的代码,解决线程安全问题
    public static synchronized SingletonHungry3 getInstance() {
        if(instance == null) {
            instance = new SingletonHungry3();
        }
        return instance;
    }
}

/**
 * @create fanzixia 调用方法类
 * @time 2022/4/25 23:16
 */
public class SingletonTest {

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

}

 执行结果

优缺点:

  1. 使用时才创建对象,节省内存开销,线程安全
  2. getInstance方法每次只能一个线程通过,效率低

 懒汉式(双重检查)

/**
 * @create fanzixia 实体类
 * @time 2022/4/25 23:13
 */
public class SingletonHungry4 {
    //构造器私有化
    private SingletonHungry4() {
    }
    private static SingletonHungry4 instance;
    //提供一个静态的公有方法,加入同步处理的代码,解决线程安全问题
    public static SingletonHungry4 getInstance() {
        if (instance == null) {
            synchronized (SingletonHungry4.class) {
                if (instance == null) {
                    instance = new SingletonHungry4();
                }
            }
        }
        return instance;
    }
}

/**
 * @create fanzixia 调用方法
 * @time 2022/4/25 23:16
 */
public class SingletonTest {

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

}

 执行结果

优缺点:

  1. 使用时才创建对象,节省内存开销,线程安全
  2. 只有刚开始getInstance方法只允许一个线程通过,对象初始化成功之后可以多线程通过,既保证线程又提高了效率

  懒汉式(静态内部类)

/**
 * @create fanzixia 实体类
 * @time 2022/4/25 23:13
 */
public class SingletonHungry5 {
    //构造器私有化
    private SingletonHungry5() {
    }
    //写一个静态内部类,该类中有一个静态属性 Singleton
    private static class SingletonInstance {
        private static final SingletonHungry5 INSTANCE = new SingletonHungry5();
    }
    //提供一个静态的公有方法,直接返回 SingletonInstance.INSTANCE
    public static synchronized SingletonHungry5 getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

/**
 * @create fanzixia 调用方法
 * @time 2022/4/25 23:16
 */
public class SingletonTest {

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

}

 执行结果

优缺点:

  1. 利用静态内部类在外部类初始化的时候并不会初始化的特点,解决了内存浪费问题
  2. 当第一次调用是,静态内部类会被初始化,类初始化的时候是线程安全的
  3. 类加载后不会被第二次加载,保证了效率 

 分享总结 | 如有侵权请联系删除

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值