聊一聊单例及框架中的单例

前言

        单例模式是设计模式中最简单也是最经常使用的设计模式之一，单例顾名思义就是系统中只有惟一实例，这个惟一实例的获取方式就是经过一个方法的调用得到，而不是经过正常流程中的new实例化。多年前在学习设计模式时就了解到单例有多种实现方式，今天就来总结一下，而且探索一下在当前java生态框架中的应用场景。

正文

        先回顾一下单例的几种实现方式，懒汉式、饿汉式、枚举实现。

懒汉式

        懒汉式指的是在服务启动时并不建立单例的实例，而是在须要时建立，而且为了保证线程安全，在建立时方法设置了同步锁。

public class LazySingleton {
    private static LazySingleton instance;
    private LazySingleton(){}
    public static synchronized LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}
复制代码

        还存在一种对上面的改进，为了提高效率，防止多个线程访问getSingleton时的，只是在建立单例实例时再去加同步锁。

public class LazySingletonV2 {
    private volatile static LazySingletonV2 singleton;
    private LazySingletonV2(){}
    public static LazySingletonV2 getSingleton() {
        if (singleton == null) {
            synchronized (LazySingletonV2.class) {
                if (singleton == null) {
                    singleton = new LazySingletonV2();
                }
            }
        }
        return singleton;
    }
}
复制代码

饿汉式

        饿汉式则比较直接，在服务启动时就已经初始化好了单例实例，比较推荐。

public class HunSingleton {

    private static HunSingleton instance = new HunSingleton();

    private HunSingleton() {
    }

    public static HunSingleton getInstance() {
        return instance;
    }
}
复制代码

枚举类型

        上述的一些方式均可能会被反射等方式破坏单例，所以又衍生出了枚举的单例，以下：

public class EnumSingleton {
    private EnumSingleton(){}
    public static EnumSingleton getInstance(){
        return Singleton.INSTANCE.getInstance();
    }
    private static enum Singleton{
        INSTANCE;

        private EnumSingleton singleton;
        //JVM会保证此方法绝对只调用一次
        private Singleton(){
            singleton = new EnumSingleton();
        }
        public EnumSingleton getInstance(){
            return singleton;
        }
    }
}
复制代码

应用场景

        上述是几种单例的简单实现方式，那Java生态中也有不少框架用到了单例模式。如spring ioc的bean管理、log4j日志管理框架等。

spirng框架

        对于最经常使用的spring框架来讲，咱们常常用spring来帮咱们管理一些无状态的bean，其默认设置为单例，这样在整个spring框架的运行过程当中，即便被多个线程访问和调用，这些“无状态”的bean就只会存在一个，为他们服务。那么“无状态”bean指的是什么呢？

        无状态：当前咱们托管给spring框架管理的javabean主要有service、mybatis的mapper、一些utils，这些bean中通常都是与当前线程会话状态无关的，没有本身的属性，只是在方法中会处理相应的逻辑，每一个线程调用的都是本身的方法，在本身的方法栈中。

        有状态：指的是每一个用户有本身特有的一个实例，在用户的生存期内，bean保持了用户的信息，即“有状态”；一旦用户灭亡（调用结束或实例结束），bean的生命期也告结束。即每一个用户最初都会获得一个初始的bean，所以在将一些bean如User这些托管给spring管理时，须要设置为prototype多例，由于好比user，每一个线程会话进来时操做的user对象都不一样，所以须要设置为多例。

        但spring框架在实现对bean管理时，跟上述的懒汉、饿汉均不相同，是经过ConcurrentHashMap单例注册表的方式实现的，在这就再也不多阐述。

        单例bean的一些优点与劣势：

优点： 1.减小了新生成实例的消耗，spring会经过反射或者cglib来生成bean实例这都是耗性能的操做，其次给对象分配内存也会涉及复杂算法； 2.减小jvm垃圾回收； 3.能够快速获取到bean；

劣势： 单例的bean一个最大的劣势就是要时刻注意线程安全的问题，由于一旦有线程间共享数据变极可能引起问题。

log4j

        在使用log4j框架时也注意到了其使用的是单例，固然也为了保证单个线程对日志文件的读写时不出问题，与使用spring管理bean的目标不是类似，以下为其logfactory单例建立的源码：

class Log4jLoggerFactory {
    private static ConcurrentMap<String, Logger> log4jLoggers = new ConcurrentHashMap();

    Log4jLoggerFactory() {
    }

    public static Logger getLogger(String name) {
        Logger instance = (Logger)log4jLoggers.get(name);
        if (instance != null) {
            return instance;
        } else {
            Logger newInstance = new Logger(name);
            Logger oldInstance = (Logger)log4jLoggers.putIfAbsent(name, newInstance);
            return oldInstance == null ? newInstance : oldInstance;
        }
    }

    public static Logger getLogger(String name, LoggerFactory loggerFactory) {
        Logger instance = (Logger)log4jLoggers.get(name);
        if (instance != null) {
            return instance;
        } else {
            Logger newInstance = loggerFactory.makeNewLoggerInstance(name);
            Logger oldInstance = (Logger)log4jLoggers.putIfAbsent(name, newInstance);
            return oldInstance == null ? newInstance : oldInstance;
        }
    }
}
复制代码

        既然log4j使用单例对单个文件读写，那么如何实现多线程环境下同时读写多个文件，这个博文实现了对每一个线程独立的log文件的读写，blog.csdn.net/guan0005/ar…

结语

        本文对单例模式进行了简单的总结，及目前生态中单例的实用场景，你们若是有好的实现方式或者更多的实用场景能够补充一下。