设计模式--单例模式

最新推荐文章于 2024-08-27 22:52:06 发布

书读百遍其义自见

最新推荐文章于 2024-08-27 22:52:06 发布

阅读量124

点赞数

文章标签：单例模式设计模式 java

本文链接：https://blog.csdn.net/qq_32495261/article/details/130891749

版权

文章介绍了Java中两种单例模式的实现：饱汉模式通过静态初始化确保只有一个实例，而饿汉模式则在类加载时创建单例。文章讨论了饿汉模式在并发环境下的问题及解决方案，包括使用`synchronized`关键字和`volatile`修饰符来保证线程安全，同时对比了不同实现的效率差异。

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

1.饱汉模式

package com.jva.util.design.single;

/**
 * 饱汉模式
 *
 * @author chengpingjia
 * @since 2023/4/26 11:41
 */
public class Full {

    private static final Full single = new Full();

    private Full() {
    }

    private static Full getSingle() {
        return single;
    }

}

2.1饿汉模式

package com.jva.util.design.single;

import cn.hutool.core.collection.ConcurrentHashSet;

import java.util.Set;
import java.util.concurrent.*;
import java.util.stream.IntStream;

/**
 * 饿汉模式
 *
 * @author chou
 * @since 2023/4/26 11:41
 */
public class Hunger {
    private static Hunger single = null;

    /**
     * 私有构造方法避免实例化
     */
    private Hunger() {
    }

    /**
     * 饿汉模式在使用的时候再去创建对象
     * 问题:在并发情况下可能有创建多个对象的可能
     *
     * @return
     */
    private static Hunger getSingle() {
        if (single == null) {
            single = new Hunger();
        }
        return single;
    }

    /**
     * 通过添加sync解决并发情况下创建多个对象的问题
     * 问题: sync包住了创建代码,效率比较低
     *
     * @return
     */
    private static synchronized Hunger getSingle2() {
        if (single == null) {
            single = new Hunger();
        }
        return single;
    }

    /**
     * 通过添加sync解决并发情况下创建多个对象的问题
     * 问题: sync包住了创建代码,效率比较低
     *
     * @return
     */
    private static Hunger getSingle3() {
        if (single == null) {
            synchronized (Hunger.class){
                if (single == null) {
                    single = new Hunger();
                }
            }
        }
        return single;
    }

    public static void main(String[] args) throws Exception {
//        ThreadPoolExecutor threadPoolExecutor = ThreadUtil.newExecutor(50, 10);
        Set<Integer> hashSet = new ConcurrentHashSet<>();
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(50, 100, 2L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>());
        int size = 100;
        CountDownLatch countDownLatch = new CountDownLatch(size);
        IntStream.range(0,size).forEach(i->{
            Future<Integer> future = threadPoolExecutor.submit(() -> {
                try {
                    int hashCode = Hunger.getSingle().hashCode();

                    int hashCode2 = Hunger.getSingle2().hashCode();
                    int hashCode3 = Hunger.getSingle3().hashCode();
                    hashSet.add(hashCode3);
                    return hashCode;
                } finally {
                    countDownLatch.countDown();
                }
            });
        });

        countDownLatch.await();
        // 等待线程执行完成
        hashSet.forEach(System.out::println);
    }
}

2.2饿汉模式优化版

package com.jva.util.design.single;

/**
 * 饱汉模式
 *
 * @author chengpingjia
 * @since 2023/4/26 11:41
 */
public class HungerComplete {

    /**
     * volatile 的作用是保证内存可见性和防止指令重排
     * 这里的作用是防止指令重排,首先创建对象分为三步,1分配内存空间,2初始化(调用构造方法)3内存空间指向初始化(对象已经不等于null了)
     * 如果指令重排了代码执行顺序为 1,3,2
     * 如果第一个线程在初始化对象执行了3,第二个线程执行时发现对象不为null,拿去使用(由于第二步还没有执行)这个时候会报错
     *
     */
    private static volatile HungerComplete single = null;

    private HungerComplete() {
    }

    /**
     * 通过添加sync解决并发情况下创建多个对象的问题
     * 问题: sync包住了创建代码,效率比较低
     *
     * @return
     */
    private static HungerComplete getSingle3() {
        if (single == null) {
            synchronized (HungerComplete.class){
                if (single == null) {
                    single = new HungerComplete();
                }
            }
        }
        return single;
    }

}