设计模式之单例模式

 

核心作用:保证一个类只有一个实例,并且提供一个访问该实例的全局访问点。

常见应用场景:

  1. 项目中读取配置文件的类,一般也只有一个对象。没必要每次使用配置文件的时候,都new一个对象去读取;
  2. 数据库连接池的设计一般是单利模式,因为数据库的连接是很耗资源的;
  3. 在servlet中的Application也是单利模式;
  4. 在Spring中,每个Bean都是单利的,这样的优点就是Spring容器可以去管理;
  5. 在Servet编程中,每个servlet也是单例的;
  6. springMVC中的控制器也是单例的;

单例模式的优点:

  - 由于单例模式只生成一个实例,减少了系统性能开销,当一个对象产生需要消耗较多资源时,如读取配置文件、产生其他依赖对象时,则可以通过在启动时直接创建出一个对象,然后永久驻留内存的方式来解决

  - 单例模式可以在系统设置全局的访问点,优化环共享资源的访问

常见的四种单例模式的实现方式:

  -饿汉式(线程安全,调用效率高,不能延时加载)

  -懒汉式(线程安全,调用效率不高,可延时加载)

  -静态内部类式(线程安全,调用效率高,可延时加载)

  -枚举单例(线程安全,调用效率高,不能延时加载,并且可以避免通过反射和序列化创建新对象)

选用方式:

  单例对象占用资源少,不需要延时加载

    枚举式 好于 饿汉式;

  单例对象占用资源大,需要延时加载

    静态内部类式 好于 懒汉式;

饿汉式

  实现类:

/**
 * <p>
 * SingletonTest01 单例模式测试类:饿汉式
 * <p>*/
public class SingletonTest01 {
    //类初始化装载的时候,初始化该对象(类初始化是天然的线程安全)
    private static SingletonTest01 instance = new SingletonTest01();

    // 私有的构造器
    private SingletonTest01() {

    }

    // 方法没有同步块,并发效率高
    public static SingletonTest01 getInstance() {
        return instance;
    }
}

  测试类:

public class Client {

    public static void main(String[] args) {
        SingletonTest01 s1 = SingletonTest01.getInstance();
        SingletonTest01 s2 = SingletonTest01.getInstance();
        
        System.out.println(s1);
        System.out.println(s2);
    }
}

  测试结果:

  

  说明:

    饿汉式单例模式中,static变量会在类装载的时候初始化,此时也不会涉及多线程的访问问题,即虚拟机只会装载一次该类,肯定不会发生多线程访问问题,因此可以省略synchronized关键字。

  缺点:

    如果加载了该类,但是在程序中没有调用getInstance(),或者永远没有调用,会造成资源浪费。

懒汉式:

  测试代码:

/**
 * <p>
 * SingletonTest02 单例模式:懒汉式
 * <p>*/
public class SingletonTest02 {

    //类初始化装载的时候,不初始化该对象(延时加载,真正使用的时候再创建)
    private static SingletonTest02 instance;

    private SingletonTest02() {

    }
    //方法需同步保证线程安全,调用效率低
    public static synchronized SingletonTest02 getInstance() {
        if (instance != null) {
            return instance;
        } else {
            return new SingletonTest02();
        }
    }
}

  测试类及测试结果同上!

  说明:实现了懒加载!

  缺点:由于每次都要同步,并发效率低!

静态内部类实现方式:

  测试类:

/**
 * <p>
 * SingletonTest03 静态内部类实现单例模式
 * <p>*/
public class SingletonTest03 {

    private static class SingletonInstance {
        private static final SingletonTest03 instance = new SingletonTest03();
    }
    // 方法没有同步,调用效率高
    public static SingletonTest03 getInstance() {
        return SingletonInstance.instance;
    }
    private SingletonTest03() {

    }
}

  说明:外部类没有static属性,则不会像饿汉式立即加载对象;只有在真正调用getInstance()才会加载静态内部类。由于加载类是线程安全的,instance是static final 类型,保证内存中只有一个实例存在,而且只能被赋值一次,从而保证线程安全性;所以静态内部类实现单例模式兼备了并发高效和懒加载双重优势

枚举实现单例模式

public enum SingletonTest04 {
    //枚举元素是单例对象
    INSTANCE;
    //添加自己的需要操作
    public String SingletonOperator(){
        return "连接到数据库实例";
    }
}

  测试代码

public class Client {
    public static void main(String[] args) {
        SingletonTest04 s1 = SingletonTest04.INSTANCE;
        SingletonTest04 s2 = SingletonTest04.INSTANCE;
        System.out.println(s1==s2);
        System.out.println(s1.SingletonOperator());
    }
}

  说明:

    优点:实现简单;枚举本身就是单例模式,由JVM从根本上保证了线程安全,同时避免了反射和序列化的漏洞!

    缺点:没有懒加载

posted @ 2016-08-30 10:50  星星满天  阅读(279)  评论(0编辑  收藏  举报