Java 设计模式系列(五)单例模式

Java 设计模式系列(五)单例模式

单例模式确保某个类只有一个实例,而且自行实例化并向整个系统提供这个实例。

一、懒汉式单例

/**
 * 懒汉式单例类.在第一次调用的时候实例化自己
 * 1. 构造器私有化,避免外面直接创建对象
 * 2. 声明一个私有的静态变量
 * 3. 创建一个对外的公共静态方法访问该变量,如果没有变量就创建对象
 */
public class Singleton {
    private Singleton() throws InterruptedException {
        Thread.sleep(2 * 1000);
    }  

    private static Singleton single=null;
    //静态工厂方法
    public static Singleton newInstance() {
         if (single == null) {
             single = new Singleton();
         }
        return single;
    }  

    public static void main(String[] args) {
        // 多线程下不安全,可以看到 Singleton 不是同一个对象
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Singleton.newInstance());
                }
            }).start();
        }
    }
}  

Singleton 通过将构造方法限定为 private 避免了类在外部被实例化,在同一个虚拟机范围内,Singleton 的唯一实例只能通过 newInstance() 方法访问。(事实上,通过 Java 反射机制是能够实例化构造方法为 private 的类的,那基本上会使所有的 Java 单例实现失效。此问题在此处不做讨论,姑且掩耳盗铃地认为反射机制不存在。)

但是以上懒汉式单例的实现没有考虑线程安全问题,它是线程不安全的,并发环境下很可能出现多个 Singleton 实例,要实现线程安全,有以下三种方式,都是对 newInstance 这个方法改造,保证了懒汉式单例的线程安全,如果你第一次接触单例模式,对线程安全不是很了解,可以先跳过下面这三小条,去看饿汉式单例,等看完后面再回头考虑线程安全的问题:

(1) 在 newInstance 方法上加同步

public class Singleton {
    private Singleton() {}
    private static Singleton single=null;
    //静态工厂方法
    public static synchronized Singleton newInstance() {
         if (single == null) {
             single = new Singleton();
         }
        return single;
    }
} 

(2) 双重检查锁定

为处理同步延迟加载方式瓶颈问题,我们需要对 instance 进行第二次检查,目的是避开过多的同步(因为这里的同步只需在第一次创建实例时才同步,一旦创建成功,以后获取实例时就不需要同获取锁了),但在 Java 中行不通,因为同步块外面的 if (instance == null) 可能看到已存在,但不完整的实例。JDK5.0 以后版本若 instance 为 volatile 则可行:

public class Singleton {
    private volatile static Singleton instance = null;
    private Singleton() {
    }  

    public static Singleton newInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {// 1
                if (instance == null) {     // 2
                    instance = new Singleton();// 3
                }
            }
        }
        return instance;
    }
}   

可以看到里面加了 volatile 关键字来声明单例对象,既然 synchronized 已经起到了多线程下原子性、有序性、可见性的作用,为什么还要加 volatile 呢,原因已经在下面评论中提到:

《单例模式与双重检测》:http://www.iteye.com/topic/652440

(3) 静态内部类

public class Singleton {
    private static class LazyHolder {
       private static final Singleton INSTANCE = new Singleton();
    }
    private Singleton (){}
    public static final Singleton newInstance() {
       return LazyHolder.INSTANCE;
    }
}     

这种比上面 1、2 都好一些,既实现了线程安全,又避免了同步带来的性能影响。

二、饿汉式单例

// 饿汉式单例类:在类初始化时,已经自行实例化
public class Singleton {
    private Singleton() {}
    private static final Singleton single = new Singleton();
    //静态工厂方法
    public static Singleton newInstance() {
        return single;
    }
}  

饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用,以后不再改变,所以天生是线程安全的。

三、登记式单例(可忽略)

//类似Spring里面的方法,将类名注册,下次从里面直接获取。
public class Singleton {
    private static Map<String,Singleton> map = new HashMap<String,Singleton>();
    static{
        Singleton single = new Singleton();
        map.put(single.getClass().getName(), single);
    }
    //保护的默认构造子
    protected Singleton() {}
    //静态工厂方法,返还此类惟一的实例
    public static Singleton newInstance(String name) {
        if(name == null) {
            name = Singleton.class.getName();
            System.out.println("name == null"+"--->name="+name);
        }
        if(map.get(name) == null) {
            try {
                map.put(name, (Singleton) Class.forName(name).newInstance());
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
        return map.get(name);
    }
    //一个示意性的商业方法
    public String about() {
        return "Hello, I am RegSingleton.";
    }
    public static void main(String[] args) {
        Singleton single3 = Singleton.newInstance(null);
        System.out.println(single3.about());
    }
}  

登记式单例实际上维护了一组单例类的实例,将这些实例存放在一个 Map(登记薄)中,对于已经登记过的实例,则从 Map 直接返回,对于没有登记的,则先登记,然后返回。

这里我对登记式单例标记了可忽略,我的理解来说,首先它用的比较少,另外其实内部实现还是用的饿汉式单例,因为其中的 static 方法块,它的单例在类被装载的时候就被实例化了。

三、饿汉式和懒汉式区别

从名字上来说,饿汉和懒汉,饿汉就是类一旦加载,就把单例初始化完成,保证 newInstance 的时候,单例是已经存在的了,而懒汉比较懒,只有当调用 newInstance 的时候,才回去初始化这个单例。

另外从以下两点再区分以下这两种方式:

1、线程安全:

饿汉式天生就是线程安全的,可以直接用于多线程而不会出现问题,

懒汉式本身是非线程安全的,为了实现线程安全有几种写法,分别是上面的1、2、3,这三种实现在资源加载和性能方面有些区别。

2、资源加载和性能:

饿汉式在类创建的同时就实例化一个静态对象出来,不管之后会不会使用这个单例,都会占据一定的内存,但是相应的,在第一次调用时速度也会更快,因为其资源已经初始化完成,

而懒汉式顾名思义,会延迟加载,在第一次使用该单例的时候才会实例化对象出来,第一次调用时要做初始化,如果要做的工作比较多,性能上会有些延迟,之后就和饿汉式一样了。

至于 1、2、3 这三种实现又有些区别,

第 1 种,在方法调用上加了同步,虽然线程安全了,但是每次都要同步,会影响性能,毕竟 99% 的情况下是不需要同步的;

第 2 种,在 newInstance 中做了两次 null 检查,确保了只有第一次调用单例的时候才会做同步,这样也是线程安全的,同时避免了每次都同步的性能损耗;

第 3 种,利用了 classloader 的机制来保证初始化 instance 时只有一个线程,所以也是线程安全的,同时没有性能损耗,所以一般我倾向于使用这一种。



每天用心记录一点点。内容也许不重要,但习惯很重要!

原文地址:https://www.cnblogs.com/binarylei/p/8996161.html

时间: 2024-10-09 05:34:07

Java 设计模式系列(五)单例模式的相关文章

Java设计模式系列之单例模式

单例模式的定义 一个类有且仅有一个实例,并且自行实例化向整个系统提供.比如,多程序读取一个配置文件时,建议配置文件时,建议配置文件封装成对象.会方便操作其中的数据,又要保证多个程序读到的是同一个配置文件对象,就需要该配置文件对象在内存中是唯一的. 单例模式的作用 简单说来,单例模式(也叫单件模式)的作用就是保证在整个应用程序的生命周期中,任何一个时刻,单例类的实例都只存在一个(当然也可以不存在). 单例模式的类图 如何保证对象的唯一性 思想:(1)不让其他程序创建该类对象; (2)在本类中创建一

23种设计模式系列之单例模式

本文继续介绍23种设计模式系列之单例模式. 概念: Java中单例模式是一种常见的设计模式,单例模式的写法有好几种,这里主要介绍三种:懒汉式单例.饿汉式单例.登记式单例. 单例模式有以下特点: 1.单例类只能有一个实例. 2.单例类必须自己创建自己的唯一实例. 3.单例类必须给所有其他对象提供这一实例. 单例模式确保某个类只有一个实例,而且自行实例化并向整个系统提供这个实例.在计算机系统中,线程池.缓存.日志对象.对话框.打印机.显卡的驱动程序对象常被设计成单例.这些应用都或多或少具有资源管理器

Java设计模式(五)外观模式 桥梁模式

(九)外观模式 外观模式为子系统提供一个接口,便于使用.解决了类与类之间关系的,外观模式将类之间的关系放在一个 Facade 类中,降低了类类之间的耦合度,该模式不涉及接口. class CPU { public void startup(){ System.out.println("cpu start"); } public void shutdown(){ System.out.println("cpu stop"); } } class Memory { pu

Java 设计模式系列(六)适配器模式

Java 设计模式系列(六)适配器模式 适配器模式把一个类的接口变换成客户端所期待的另一种接口,从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作. 适配器模式的结构: 类的适配器模式 对象的适配器模式 一.类适配器模式 类的适配器模式把适配的类的 API 转换成为目标类的 API. 在上图中可以看出,Adaptee 类并没有 sampleOperation2() 方法,而客户端则期待这个方法.为使客户端能够使用 Adaptee 类,提供一个中间环节,即类 Adapter,把 Adap

Java 设计模式系列(九)组合模式

Java 设计模式系列(九)组合模式 将对象组合成树形结构以表示"部分-整体"的层次结构.组合模式使得用户对单个对象的使用具有一致性. 一.组合模式结构 Component: 抽象的组件对象,为组合中的对象声明接口,让客户端可以通过这个接口来访问和管理整个对象结构,可以在里面为定义的功能提供缺省的实现. Leaf: 叶子节点对象,定义和实现叶子对象的行为,不再包含其它的子节点对象. Composite: 组合对象,通常会存储子组件,定义包含子组件的那些组件的行为,并实现在组件接口中定义

Java 设计模式系列(十六)观察者模式(Observer)

Java 设计模式系列(十六)观察者模式(Observer) 观察者模式是对象的行为模式,又叫发布-订阅(Publish/Subscribe)模式.模型-视图(Model/View)模式.源-监听器(Source/Listener)模式或从属者(Dependents)模式. 观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象.这个主题对象在状态上发生变化时,会通知所有观察者对象,使它们能够自动更新自己. 一.观察者模式的结构 Subject:目标对象,通常具有如下功能:

Java 设计模式系列(二三)访问者模式(Vistor)

Java 设计模式系列(二三)访问者模式(Vistor) 访问者模式是对象的行为模式.访问者模式的目的是封装一些施加于某种数据结构元素之上的操作.一旦这些操作需要修改的话,接受这个操作的数据结构则可以保持不变. 一.访问者模式结构 访问者模式适用于数据结构相对未定的系统,它把数据结构和作用于结构上的操作之间的耦合解脱开,使得操作集合可以相对自由地演化. 数据结构的每一个节点都可以接受一个访问者的调用,此节点向访问者对象传入节点对象,而访问者对象则反过来执行节点对象的操作.这样的过程叫做"双重分派

java设计模式系列之设计模式概要(1)

一.什么是设计模式 设计模式(Design pattern)是一套被反复使用.多数人知晓的.经过分类编目的.代码设计经验的总结.使用设计模式是为了可重用代码.让代码更容易被他人理解.保证代码可靠性. 毫无疑问,设计模式于己于他人于系统都是多赢的,设计模式使代码编制真正工程化,设计模式是软件工程的基石,如同大厦的一块块砖石一样.项目中合理的运用设计模式可以完美的解决很多问题,每种模式在现在中都有相应的原理来与之对应,每一个模式描述了一个在我们周围不断重复发生的问题,以及该问题的核心解决方案,这也是

《Java设计模式》之单例模式

在GoF的23种设计模式中,单例模式是比较简单的一种.然而,有时候越是简单的东西越容易出现问题.下面就单例设计模式详细的探讨一下. 所谓单例模式,简单来说,就是在整个应用中保证只有一个类的实例存在.就像是Java Web中的application,也就是提供了一个全局变量,用处相当广泛,比如保存全局数据,实现全局性的操作等. 1. 最简单的实现 首先,能够想到的最简单的实现是,把类的构造函数写成private的,从而保证别的类不能实例化此类,然后在类中提供一个静态的实例并能够返回给使用者.这样,