关闭

《设计模式》学习笔记5——单例模式【高并发拓展】

标签: 设计模式单例模式
212人阅读 评论(0) 收藏 举报
分类:

定义

单例模式又称为单件模式,这个模式大概是设计模式中最好理解的了,我起初就打算从这里开始学,甚至还记过另一篇单例模式学习的笔记。
但是之后跟着《设计模式》这本书系统的学,就索性从第一页开始,而单例模式算是复习,也算是再深入的理解一次。
之所以要这么做,是因为上一次写的没有给出更标准的定义,同时,当时只介绍了基础的懒汉式和饿汉式,对于并发时候的单例却没有涉及,所以这篇学习的重点应当在于高并发时如何保证我们的单例依旧是单例。
单例模式引用书中的定义如下:

单例模式(Singleton Pattern):确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例,这个类称为单例类,它提供全局访问的方法。单例模式是一种对象创建型模式

理解

由于之前写过一篇单例模式的记录,里边对基础饿汉式和懒汉式的介绍都还算详细,因此整个基础饿汉式和懒汉式的使用及理解这里就没有必要赘述,以下是那篇的链接:
https://tuzongxun.github.io/2017/09/24/pattern1_danli/
https://yq.aliyun.com/articles/210401?spm=5176.8091938.0.0.1wWDAm
http://blog.csdn.net/tuzongxun/article/details/78009213

要点

饿汉式和懒汉式的不同,在于单例对象的创建时机,一个是直到第一次被用的时候才创建,一个是不管有没有人用,反正先创建了放这里再说。
这就映射了现实生活中的两类人,一类是有备无患,一种是临时抱佛脚。
既然他们都是单例模式,自然就有属于单例模式的共性,总结下来基本如下:
1. 构造器私有化,不允许自己之外的他人创建
2. 在上一条的前提下,就必须自己创建自己的实例对象
3. 为了保证实例对象唯一,这个实例对象必须是静态的,属于类
4. 外部不能用new获得这个对象,那么就必须提供一个外部能访问的静态方法,返回自己的实例对象

拓展

开篇说到这一篇的重点应该在于高并发时如何保证单例对象还是单例,那么首先必须是高并发时会出现不再单例的问题,这个问题实际上只会出现在懒汉式的情况中。(注:这似乎也警示着人们,人还是勤快点好啊)
那么我们先来看一下饿汉式的写法:

package patterntest.singletonpattern;

/**
 * 单例模式——饿汉式
 * 
 * @author tzx
 * @date 2017年11月23日
 */
public class SingletonPattern1 {
    private static SingletonPattern1 singletonPattern1 = new SingletonPattern1();

    private SingletonPattern1() {

    }

    public static SingletonPattern1 getInstance() {
        return singletonPattern1;
    }
}

在饿汉式中,一开始初始化类的时候就创建了类的实例对象,也就是说在被使用之前就已经创建,这时候即便是多个线程同时来取这个对象,也依旧还是这同一个对象,不会有任何问题。
然后再看一下懒汉式的写法:

package patterntest.singletonpattern;

/**
 * 单例模式——懒汉式
 * 
 * @author tzx
 * @date 2017年11月23日
 */
public class SingletonPattern2 {
    private static SingletonPattern2 singletonPattern2;

    private SingletonPattern2() {

    }

    public static SingletonPattern2 getInstance() {
        if (singletonPattern2 == null) {
            singletonPattern2 = new SingletonPattern2();
        }
        return singletonPattern2;
    }
}

在懒汉式中,当有消费者需要获取当前类的对象时,会先判断该对象是否是null,如果是,才会创建一个对象。
那么我们知道在高并发的时候,线程可能在任何时候让出cpu,也就是说如果有两条线程,当第一条读到singletonPattern2 == null为true后,还没有来得及new一个对象,这时候让出了cpu,另一个线程接手了。
然后第二个线程再进行if判断的时候会发现依旧是true,然后他就new了一个对象出来,然后让出cpu。
结果第一个线程接手后接着之前的判断结果进行处理,就会再new一个对象出来,这时候我们的单例便不再是单例了。
为了演示这种情况,我们对懒汉模式稍作改造:

package patterntest.singletonpattern;

/**
 * 单例模式——懒汉式
 * 
 * @author tzx
 * @date 2017年11月23日
 */
public class SingletonPattern2 {

    private static SingletonPattern2 singletonPattern2;

    private SingletonPattern2() {

    }

    public static SingletonPattern2 getInstance() {
        if (singletonPattern2 == null) {
            try {
                Thread.yield();
            } catch (Exception e) {
                e.printStackTrace();
            }
            singletonPattern2 = new SingletonPattern2();
        }
        return singletonPattern2;
    }
}

在上边的代码中,我们调用Thread.yield()手动在new一个对象之前使当前线程让出剩余cpu时间,这时候下一个线程就会执行,然后写一个测试多线程调用的类及方法:

package patterntest.singletonpattern;

/**
 * 单例模式测试
 * 
 * @author tzx
 * @date 2017年11月23日
 */
public class Consumer {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new MyRunnable());
        thread1.start();
        Thread thread2 = new Thread(new MyRunnable());
        thread2.start();
    }

}

class MyRunnable implements Runnable {
    public void run() {
        SingletonPattern2 singletonPattern2 = SingletonPattern2.getInstance();
        System.out.println(singletonPattern2 + ":" + singletonPattern2.hashCode());

        SingletonPattern1 singletonPattern1 = SingletonPattern1.getInstance();
        System.out.println(singletonPattern1 + ":" + singletonPattern1.hashCode());

    }
}

上述代码应该比较简单,启动两个线程,在线程的run方法里获取我们的单例对象,然后打印出hashcode。我们知道,同一个对象的hashcode应该是一样的,但是运行上边的代码之后结果如下:

patterntest.singletonpattern.SingletonPattern2@51ab0bbe:1370164158
patterntest.singletonpattern.SingletonPattern2@4ab73ee:78345198
patterntest.singletonpattern.SingletonPattern1@5f6cfffb:1600978939
patterntest.singletonpattern.SingletonPattern1@5f6cfffb:1600978939

很明显,两个Pattern2的hashcode值不一样,而两个Pattern1的hashcode是完全一样的,进一步证明了懒汉式的单例模式并不能保证在多线程、高并发时保证单例,那么这时候就需要涉及到线程同步的知识,可以使用同步锁synchronized锁住我们的getInstance方法,代码就可以改成这样:

public synchronized static SingletonPattern2 getInstance() {
    if (singletonPattern2 == null) {
        try {
            Thread.yield();
        } catch (Exception e) {
            e.printStackTrace();
        }
        singletonPattern2 = new SingletonPattern2();
    }
    return singletonPattern2;
}

这时候无论我们再运行多少次测试方法,可以保证Pattern2的所有对象的hashcode都是同一个,也就是保证了Pattern2对象是一个单例对象,就像下边这样:

patterntest.singletonpattern.SingletonPattern2@4ab73ee:78345198
patterntest.singletonpattern.SingletonPattern2@4ab73ee:78345198
patterntest.singletonpattern.SingletonPattern1@a6c9d0b:174890251
patterntest.singletonpattern.SingletonPattern1@a6c9d0b:174890251

上边的问题确实解决了多线程高并发时单例对象不单例的问题,然后由于锁定的是方法,所以必然在高并发时影响性能,所以我们需要进一步优化,从锁方法缩小到只锁住创建对象的那一段代码,也就是所谓的锁定代码块:

// public synchronized static SingletonPattern2 getInstance() {
    public static SingletonPattern2 getInstance() {
        // if (singletonPattern2 == null) {
        // try {
        // Thread.yield();
        // } catch (Exception e) {
        // e.printStackTrace();
        // }
        // singletonPattern2 = new SingletonPattern2();
        // }
        if (singletonPattern2 == null) {
            try {
                Thread.yield();
            } catch (Exception e) {
                e.printStackTrace();
            }
            synchronized (SingletonPattern2.class) {
                singletonPattern2 = new SingletonPattern2();
            }

        }
        return singletonPattern2;
    }

但是仔细看上边的代码,或者运行一下测试方法会发现,这种写法实际上并不能解决单例对象不单例的情况,此时的锁其实是个无意义的锁。所以我们需要把这个锁进一步优化,使用双重检查锁定机制,然后代码就应该是这样:

public static SingletonPattern2 getInstance() {
    if (singletonPattern2 == null) {
        try {
            Thread.yield();
        } catch (Exception e) {
            e.printStackTrace();
        }
        synchronized (SingletonPattern2.class) {
            if (singletonPattern2 == null) {
            singletonPattern2 = new SingletonPattern2();
            }
        }

    }
    return singletonPattern2;
}

这样一来,在调用这个getInstance方法的时候就不会被直接锁住,而是先进行一个判断后才锁定,提升了系统性能。
同时,由于锁里边又进行了判断,就可以进一步保证对象的唯一性。
然而,上边的结论其实是我想当然的结论,按书中所说,这样也并不能完全保证单例,还需要给对象增加一个修饰词volatile,然后整个类就应该是这个样子:

package patterntest.singletonpattern;

/**
 * 单例模式——懒汉式
 * 
 * @author tzx
 * @date 2017年11月23日
 */
public class SingletonPattern2 {

    private volatile static SingletonPattern2 singletonPattern2;

    private SingletonPattern2() {

    }

    public static SingletonPattern2 getInstance() {
        if (singletonPattern2 == null) {
            try {
                Thread.yield();
            } catch (Exception e) {
                e.printStackTrace();
            }
            synchronized (SingletonPattern2.class) {
                if (singletonPattern2 == null) {
                singletonPattern2 = new SingletonPattern2();
                }
            }

        }
        return singletonPattern2;
    }
}

不过那种不加volatile修饰符而出现不单例的情况应该并不多见,因为为了验证这一情况,我写了一个for循环创建线程来测试,即便是循环数万次,也依旧没有出现不一致的情况。

demo源码可在github下载:https://github.com/tuzongxun/mypattern

0
0
查看评论
发表评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场

高并发下线程安全的单例模式(最全最经典)

分类: 设计模式(5)  版权声明:本文为博主原创文章,未经博主允许不得转载。 目录(?)[-] 什么是单例模式各式各样的单例实现 饿汉式单例懒汉式单...
  • pingdouble
  • pingdouble
  • 2016-10-20 16:49
  • 833

[并发并行]_[线程同步]_[C/C++实现单例模式分析]

场景: 1. 很多情况下,我们需要实现一个类的单例模式,比如XXManager, 于是提供一个GetInstance()的函数. Java可以使用双锁来处理.C/C++也类似. 2. 提供GetIns...
  • infoworld
  • infoworld
  • 2015-11-12 14:14
  • 2508

Java高并发程序设计笔记9之并发设计模式

 什么是设计模式   单例模式   不变模式   Future模式   生产者消费者  什么是设计模式  在软件工程中,设计模式(design pattern)是对软件设计中普遍存在(反复...
  • jiangzhexi
  • jiangzhexi
  • 2016-12-21 22:01
  • 773

设计模式——单例模式的几种实现方式

1.饿汉式:静态常量 这种方法非常的简单,因为单例的实例被声明成static和final变量了,在第一次加载类到内存中时就会初始化,所以会创建实例本身是线程安全的。public class Singl...
  • bingogirl
  • bingogirl
  • 2016-09-01 00:03
  • 1175

设计模式学习笔记---单例模式(Java版)

GOF23(Group of  four) 创建型模式 单例模式,工厂模式,抽象工厂模式,建造者模式,原型模式。 结构型模式 适配器模式,桥接模式,装饰模式,组合模式,外观模式,享元模式,代理模式...
  • scgaliguodong123_
  • scgaliguodong123_
  • 2015-01-09 09:30
  • 1113

Java中的单例模式的优秀实现

单例模式不得不说应该算初学者接触的最早几个设计模式之一了,主要是因为它的应用场景比起什么其他模式太简单易懂了,我们都知道,你要一个总体控制的类,比如一个能够初始化功能,提供特定功能的Helper类,那...
  • ll530304349
  • ll530304349
  • 2016-09-21 15:25
  • 412

设计模式:单例模式(Singleton)

单例模式在23个设计模式中算得上是最简单的一个了,也行你会有异议,那就换成“最简单之一”,这样就严谨了很多。   单例模式:保证一个类仅有一个实例,并提供一个访问它的全局访问点。   适用性:当类...
  • u013256816
  • u013256816
  • 2016-03-23 21:37
  • 4747

java设计模式之单例模式(几种写法及比较)

概念:   java中单例模式是一种常见的设计模式,单例模式的写法有好几种,这里主要介绍三种:懒汉式单例、饿汉式单例、登记式单例。   单例模式有以下特点:   1、单例类只能有一个实例。  ...
  • tolcf
  • tolcf
  • 2015-10-21 22:56
  • 6146

C++设计模式[二]单例模式

接着就是单例模式;个人理解就是把创建方法改为私有,然后再内部实例化,禁止外部创建对象。 何为单例模式,在GOF的《设计模式:可复用面向对象软件的基础》中是这样说的:保证一个类只有一个实例,并提供一个...
  • langb2014
  • langb2014
  • 2015-11-03 16:11
  • 1004

设计模式(二)单例模式的七种写法

面试的时候,问到许多年轻的Android开发他所会的设计模式是什么,基本上都会提到单例模式,但是对单例模式也是一知半解,在Android开发中我们经常会运用单例模式,所以我们还是要更了解单例模式才对。...
  • itachi85
  • itachi85
  • 2016-01-17 10:29
  • 23780
    有问题要问?点击QQ联系我!
    有需要,qq联系我
    1160569243
    公告栏
    个人资料
    • 访问:791089次
    • 积分:10012
    • 等级:
    • 排名:第2015名
    • 原创:230篇
    • 转载:38篇
    • 译文:0篇
    • 评论:411条