5种单例模式

单例核心作用：

保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。

常见应用场景：

1.windos系统的任务管理器

2.回收站，在整个系统运行过程中，回收站一直维护者仅有的一个实例

3.项目中，读取配置文件的，一般也只有一个对象，没有必要每次使用配置文件数据，每次去New一个对象去读取

4.网站的计数器，一般也采用单例，否则难以同步。

5.应用程序的日志应用，这是由于共享的日志文件一直处于打开状态，因此只能有一个实例去操作，否则内容不好追加

6.数据库连接池的设计一般也是采用单例模式，节省资源，因为数据库连接是一种数据库资源

7操作系统的文件系统，也是大的单例模式的例子，一个操作系统只能有一个文件系统。

8.Application也是单例的典型应用（Servlet编程中会涉及到）。

9.Spring中，每个Bean默认就是单例的，这样做的优点时Spring容器可以管理

10.Servlet编程中，每个Servlet也是单例

11.SpringMvc/Struts1框架中，控制器对象也是单例的

饿汉式：（线程安全，调用效率高，但是不能延时加载）

延时加载：类加载的时候即创建实例

/**
 * 测试饿汉式单例
 */
public class SingletonDemo01 {
 
    //上来就实例化，类初始化立即加载这个对象，没有延时加载
    //天然的是线程安全的
   //垃圾回收机制是不会回收这个对象的
    private static SingletonDemo01 instance = new SingletonDemo01();
 
    //私有化构造方法
    private SingletonDemo01() {
 
    }
 
    //方法没有同步，调用效率高
    public static SingletonDemo01 getInstance() {
        return instance;
    }
 
    public static void main(String[] args) {
        SingletonDemo01 u01=new SingletonDemo01();
        SingletonDemo01 u02=new SingletonDemo01();
        System.out.println(u01==u02);
    }
}

 

懒汉式（线程安全，调用效率不高，但是可以延时加载）

/**
 * 懒汉式单例测试
 * 实现延时加载
 */
public class SingletonDemo02 {
 
    //类初始化，不初始化这个对象，延时加载，真正用的时候再创建
    private static SingletonDemo02 instance;
 
    //私有化构造方法
    private SingletonDemo02() {
    }
 
    //synchronized实现同步,防止多个线程访问，创建多个对象，违背单例原则
    //但是调用效率低
    public static synchronized SingletonDemo02 getInstance() {
        if (instance == null) {
            instance = new SingletonDemo02();
        }
        return instance;
    }
 
    public static void main(String[] args) {
        SingletonDemo02 u01=new SingletonDemo02 ();
        SingletonDemo02 u02=new SingletonDemo02 ();
        System.out.println(u01==u02);
    }
}

双重检测锁（线程安全，效率低，由于JVM本质重排序的原因，可能会初始化多次，不建议使用）

 
/**
 * 双重检测锁实现单例模式
 * 将同步内容放到if种，提高了效率，不用每次获取对象时都进行同步
 * 只有第一次才同步，创建了以后就不用再同步了
 *
 *问题：由于编译器优化的原因和jvm底层的原因，偶尔会出问题，不建议使用
 */
public class SingtelonDemo03 {
    private volatile static SingtelonDemo03 instance;
 
    private SingtelonDemo03 () {
    }
 
    public SingtelonDemo03 getInstance() {
        if (null == instance) {
            synchronized (SingtelonDemo03 .class) {
                if (null == instance) {
                    instance = new SingtelonDemo03 ();
                }
            }
        }
        return instance;
    }
}

静态内部类（线程安全，调用效率高，可以延时加载）

/**
 * 静态内部类实现单例模式
 * 线程安全，调用效率高，并实现了延时加载
 */
public class SingletonDemo04 {
 
 
    //静态内部类，并把内部类私有
    private static class SingketonClassintance{
        private static final SingletonDemo04 instance=new SingletonDemo04();
    }
 
 
    private SingletonDemo04(){}
 
    public static SingletonDemo04 getInstance(){
        return SingketonClassintance.instance;
    }
}

枚举单例（线程安全，调用效率高，从jvm根本上提供保障，避免通过反射和反序列化的漏洞，缺点为不能延时加载）

/**
 * 枚举实现单例
 * 无延时加载
 * SingletonDemo05.INSTANCE就可以直接获得对象
 */
public enum SingletonDemo05 {
 
    //定义了一个枚举的元素，他就代表了一个单例的实例
    INSTANCE;
 
    //添加自己需要的操作
    public void singletonOperation(){
        //功能处理
    }
}

选用单例模式时：

    单例对象占用资源少，不需要延时加载： 枚举式好于饿汉式

   单例对象占用资源大，需要延时加载：     静态内部类好于懒汉式

注：通过反射和反序列化可以破坏单例（枚举除外）

转载于:https://www.cnblogs.com/QSC-AcStu/p/11416715.html