Java设计模式(一)----单例模式

  1. 云栖社区>
  2. 博客列表>
  3. 正文

Java设计模式(一)----单例模式

汤高 2016-03-28 20:29:10 浏览4703 评论1

摘要: 单例模式 一、特点: 二.分类 (一)、懒汉式单例 (二)、双重检查锁定 (三)、静态(类级)内部类 (四)、饿汉式单例 (五)、单例和枚举 三、饿汉式和懒汉式区别 一、特点: 1、单例类只能有一个实例。

单例模式
一、特点:
二.分类
(一)、懒汉式单例
(二)、双重检查锁定
(三)、静态(类级)内部类
(四)、饿汉式单例
(五)、单例和枚举
三、饿汉式和懒汉式区别


一、特点:
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。
单例模式确保某个类只有一个实例,而且自行实例化并向整个系统提供这个实例。


二.分类
(一)、懒汉式单例

//懒汉式单例类.在第一次调用的时候实例化自己   
public class Singleton {
    // 构造方法私有化
    private Singleton() {
    }
    private static Singleton single = null;
    // 静态工厂方法
    public static Singleton getInstance() {
        if (single == null) {
            single = new Singleton();
        }
        return single;
    }
}

Singleton通过将构造方法限定为private避免了类在外部被实例化,在同一个虚拟机范围内,Singleton的唯一实例只能通过getInstance()方法访问。
(事实上,通过Java反射机制是能够实例化构造方法为private的类的,那基本上会使所有的Java单例实现失效。此问题在此处不做讨论,姑且掩耳盗铃地认为反射机制不存在。)
但 是以上懒汉式单例的实现没有考虑线程安全问题,它是线程不安全的,并发环境下很可能出现多个Singleton实例,要实现线程安全,有以下三种方式,都 是对getInstance这个方法改造,保证了懒汉式单例的线程安全,如果你第一次接触单例模式,对线程安全不是很了解,可以先跳过下面这三小条,去看 饿汉式单例,等看完后面再回头考虑线程安全的问题:

1、在getInstance方法上加同步

public static synchronized  Singleton getInstance() {
        if (single == null) {
            single = new Singleton();
        }
        return single;
}

(二)、双重检查锁定
可以使用“双重检查加锁”的方式来实现,就可以既实现线程安全,又能够使性能不受很大的影响。那么什么是“双重检查加锁”机制呢?
所谓“双重检查加锁”机制,指的是:并不是每次进入getInstance方法都需要同步,而是先不同步,进入方法后,先检查实例是否存在,如 果不存在才进行下面的同步块,这是第一重检查,进入同步块过后,再次检查实例是否存在,如果不存在,就在同步的情况下创建一个实例,这是第二重检查。这样 一来,就只需要同步一次了,从而减少了多次在同步情况下进行判断所浪费的时间。
“双重检查加锁”机制的实现会使用关键字volatile,它的意思是:被volatile修饰的变量的值,将不会被本地线程缓存,所有对该变量的读写都是直接操作共享内存,从而确保多个线程能正确的处理该变量。
注意:在java1.4及以前版本中,很多JVM对于volatile关键字的实现的问题,会导致“双重检查加锁”的失败,因此“双重检查加锁”机制只只能用在java5及以上的版本。

public class Singleton {
    private volatile static Singleton instance = null;
    private Singleton(){}
    public static Singleton getInstance(){
        //先检查实例是否存在,如果不存在才进入下面的同步块
        if(instance == null){
            //同步块,线程安全的创建实例
            synchronized (Singleton.class) {
                //再次检查实例是否存在,如果不存在才真正的创建实例
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

这种实现方式既可以实现线程安全地创建实例,而又不会对性能造成太大的影响。它只是第一次创建实例的时候同步,以后就不需要同步了,从而加快了运行速度。
(摘自网络)提示:由于volatile关键字可能会屏蔽掉虚拟机中一些必要的代码优化,所以运行效率并不是很高。因此一般建议,没有特别的需要,不要使用。也就是说,虽然可以使用“双重检查加锁”机制来实现线程安全的单例,但并不建议大量采用,可以根据情况来选用。


(三)、静态(类级)内部类

public class Singleton {

    private Singleton(){}
    /**
     *    类级的内部类,也就是静态的成员式内部类,该内部类的实例与外部类的实例
     *    没有绑定关系,而且只有被调用到时才会装载,从而实现了延迟加载。
     */
    private static class SingletonHolder{
        /**
         * 静态初始化器,由JVM来保证线程安全
         */
        private static Singleton instance = new Singleton();
    }

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

这种比上面1、2都好一些,既实现了线程安全,又避免了同步带来的性能影响。 当getInstance方法第一次被调用的时候,它第一次读取 SingletonHolder.instance,导致SingletonHolder类得到初始化;而这个类在装载并被初始化的时候,会初始化它的静 态域,从而创建Singleton的实例,由于是静态的域,因此只会在虚拟机装载类的时候初始化一次,并由虚拟机来保证它的线程安全性。
这个模式的优势在于,getInstance方法并没有被同步,并且只是执行一个域的访问,因此延迟初始化并没有增加任何访问成本。


(四)、饿汉式单例

//饿汉式单例类.在类初始化时,已经自行实例化   
public class EagerSingleton {
        private static EagerSingleton instance = new EagerSingleton();
        /**
         * 构造方法私有化
         */
        private EagerSingleton(){}
        /**
         * 静态工厂方法
         */
        public static EagerSingleton getInstance(){
            return instance;
        }
}

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


(五)、单例和枚举
用枚举来实现单例非常简单,只需要编写一个包含单个元素的枚举类型即可。

public enum Singleton {
    /**
     * 定义一个枚举的元素,它就代表了Singleton的一个实例。
     */

    uniqueInstance;

    /**
     * 单例可以有自己的操作
     */
    public void singletonOperation(){
        //功能处理
    }
}

 相关测试代码:

public enum SingletonEnum {
    INSTANCE01, INSTANCE02;// 定义枚举的两个类型
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name){
        this.name = name;
    }
}


public class Test {

    public static void main(String[] args) {
            SingletonEnum instance01=SingletonEnum.INSTANCE01;
            instance01.setName("tanggao");
            System.out.println(instance01.getName());

            SingletonEnum instance02=SingletonEnum.INSTANCE01;
            System.out.println(instance02.getName());

            SingletonEnum instance03=SingletonEnum.INSTANCE02;
            instance03.setName("zsy");
            System.out.println(instance03.getName());

            SingletonEnum instance04=SingletonEnum.INSTANCE02;
            instance04.setName("zsy1");
            System.out.println(instance04.getName());
            System.out.println(instance03.hashCode()+"\t"+instance04.hashCode());
            System.out.println(instance03==instance04);

    }
}

结果:
tanggao
tanggao
zsy
zsy1
3346521 3346521
true

使用枚举来实现单实例控制会更加简洁,而且无偿地提供了序列化机制,并由JVM从根本上提供保障,绝对防止多次实例化,是更简洁、高效、安全的实现单例的方式。


三、饿汉式和懒汉式区别
从名字上来说,饿汉和懒汉,
饿汉就是类一旦加载,就把单例初始化完成,保证getInstance的时候,单例是已经存在的了,
而懒汉比较懒,只有当调用getInstance的时候,才回去初始化这个单例。
另外从以下两点再区分以下这两种方式:

1、线程安全:
饿汉式天生就是线程安全的,可以直接用于多线程而不会出现问题,
懒汉式本身是非线程安全的,为了实现线程安全有几种写法,分别是上面的1、2、3,这三种实现在资源加载和性能方面有些区别。

2、资源加载和性能:
饿汉式在类创建的同时就实例化一个静态对象出来,不管之后会不会使用这个单例,都会占据一定的内存,但是相应的,在第一次调用时速度也会更快,因为其资源已经初始化完成,
而懒汉式顾名思义,会延迟加载,在第一次使用该单例的时候才会实例化对象出来,第一次调用时要做初始化,如果要做的工作比较多,性能上会有些延迟,之后就和饿汉式一样了。
至于1、2、3这三种实现又有些区别,
第1种,在方法调用上加了同步,虽然线程安全了,但是每次都要同步,会影响性能,毕竟99%的情况下是不需要同步的,
第2种,在getInstance中做了两次null检查,确保了只有第一次调用单例的时候才会做同步,这样也是线程安全的,同时避免了每次都同步的性能损耗
第3种,保证初始化instance时只有一个线程,所以也是线程安全的,同时没有性能损耗,一般倾向于使用这一种。

3、什么是线程安全?
如果你的代码所在的进程中有多个线程在同时运行,而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的,而且其他的变量的值也和预期的是一样的,就是线程安全的。
或者说:一个类或者程序所提供的接口对于线程来说是原子操作,或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题,那就是线程安全的。

以上内容来自平时所看书籍和网络资源整理测试所得,如有不完善之处,欢迎指正!

【云栖快讯】你想见的Java技术专家都在这了,向大佬提问,有问题必答  详情请点击

网友评论

1F
我是呆呆啊

高神厉害

汤高

过奖了哈

评论
汤高
文章94篇 | 关注89
关注
兼容Jenkins标准,可提供快速可靠的持续集成与持续交付服务。基于容器技术和阿里云基础服务... 查看详情
云数据库HybridDB(ApsaraDB HybridDB)是一种在线MPP大规模并行处理... 查看详情
消息队列(Message Queue,简称MQ)是阿里云商用的专业消息中间件,是企业级互联网... 查看详情
为您提供简单高效、处理能力可弹性伸缩的计算服务,帮助您快速构建更稳定、安全的应用,提升运维效... 查看详情
阿里云总监课正式启航

阿里云总监课正式启航