单例模式用法简介

雨林15

已于 2023-08-29 22:38:07 修改

阅读量116

点赞数

分类专栏： Java 文章标签： java kotlin

于 2019-02-22 22:45:00 首次发布

本文链接：https://blog.csdn.net/sunrain62/article/details/87886785

版权

Java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

单例模式用法简介

单例模式用法简介

简介

一个类有且仅有一个实例，并且自行实例化向整个系统提供

基本用法

Kotlin 两种：不带参、带参。
Java 六种：懒汉、饿汉、双重校验锁、静态内部类、枚举和集合管理。

Kotlin 不带参

Kotlin 中使用 object 来创建单例，不允许有任何构造函数，可在 init 代码块中初始化

fun main() {
    println(SingletonNormal == SingletonNormal) // init normal -> true
    SingletonNormal.action() // action
}

object SingletonNormal {
    init {
        println("init normal")
    }
}

Kotlin 带参

fun main() {
    println(Manager.getInstance("hello") == Manager.getInstance("singleton")) // init hello -> true
    Manager.getInstance("singleton").action() // hello
}

class Manager private constructor(private val name: String) {
    companion object : SingletonHolder<Manager, String>(::Manager) {
        private const val TAG = "Manager"
    }

    init {
        println("$TAG: init $name")
    }

    fun action() {
        println("$TAG: $name")
    }
}

open class SingletonHolder<out T, in A>(creator: (A) -> T) {
    private var creator: ((A) -> T)? = creator

    @Volatile
    private var instance: T? = null

    fun getInstance(arg: A): T = instance ?: synchronized(this) {
        instance ?: creator!!(arg).also {
            instance = it
            creator = null
        }
    }
}

饿汉式

加载时实例化

public class SingletonHungry {

    private static SingletonHungry instance = new SingletonHungry();

    private SingletonHungry() {
    }

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

懒汉式

使用时实例化

public class SingletonLazy {

    private static SingletonLazy instance;

    private SingletonLazy() {
    }

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

双重校验锁

被volatile修饰的变量的值，将不会被本地线程缓存，所有对该变量的读写都是直接操作共享内存，从而确保多个线程能正确的处理该变量。

由于volatile关键字可能会屏蔽掉虚拟机中的一些必要的代码优化，所以运行效率并不是很高。

public class SingletonLock {

    private volatile static SingletonLock instance; // 关键字volatile

    private SingletonLock() {
    }

    public static SingletonLock getInstance() {
        if (instance == null) {  // 先检查实例是否存在
            synchronized (SingletonLock.class) {  // 同步块，线程安全的创建实例
                if (instance == null) {  // 再次检查实例是否存在
                    instance = new SingletonLock();
                }
            }
        }
        return instance;
    }
}

静态内部类

推荐使用

public class SingletonHolder {

    private SingletonHolder() {
    }

    public static SingletonHolder getInstance() {
        return InstanceHolder.instance;
    }

    private static class InstanceHolder {
        private static final SingletonHolder instance = new SingletonHolder();
    }
}

枚举

不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。1.5中才加入enum特性

public enum SingletonEnum {

    INSTANCE;

    public void otherMethod() {
        Log.d("SingletonEnum", String.valueOf(INSTANCE));
    }
}

集合管理

ConcurrentHashMap 线程安全Map，解决并发问题

public class SingletonManager {

    private static ConcurrentHashMap<String, Object> singletonMap = new ConcurrentHashMap<>();

    private SingletonManager() {
    }

    public static void putInstance(String key, Object instance) {
        singletonMap.putIfAbsent(key, instance);
    }

    public static Object getInstance(String key) {
        return singletonMap.get(key);
    }
}

问题

类加载器

如果单例由不同的类加载器载入，那便有可能存在多个单例类的实例。假定不是远端存取，例如一些servlet容器对每个servlet使用完全不同的类加载器，这样的话如果有两个servlet访问一个单例类，它们就都会有各自的实例。

解决方法：

private static Class getClass(String classname) throws ClassNotFoundException {
    ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
    if(classLoader == null){
        classLoader = Singleton.class.getClassLoader();
    }
    return classLoader.loadClass(classname);
}

序列化

如果Singleton实现了java.io.Serializable接口，那么这个类的实例就可能被序列化和反序列化。不管怎样，如果你序列化一个单例类的对象，接下来反序列化多个那个对象，那你就会有多个单例类的实例。

解决方法：

public class SingletonSerialize implements java.io.Serializable{

    private static SingletonSerialize instance = new SingletonSerialize();

    private SingletonSerialize() {
    }

    public static SingleSingletonSerializetonF getInstance() {
        return instance;
    }

    // 添加此方法确保反序列化单例
    private Object readResolve() throws java.io.ObjectStreamException {
        return instance;
    }
}