菜鸟学习java设计模式之单例模式

单例模式大家并不陌生,也都知道它分为什么懒汉式、饿汉式之类的。但是你对单例模式的理解足够透彻吗?今天我带大家一起来看看我眼中的单例,可能会跟你的认识有所不同。

下面是一个简单的小实例:

//简单懒汉式
public class Singleton { 

  //单例实例变量
  private static Singleton instance = null; 

  //私有化的构造方法,保证外部的类不能通过构造器来实例化
  private Singleton() {} 

  //获取单例对象实例
  public static Singleton getInstance() { 

    if (instance == null) {
      instance = new Singleton();
    } 

    System.out.println("我是简单懒汉式单例!");
    return instance;
  }
}

很容易看出,上面这段代码在多线程的情况下是不安全的,当两个线程进入if (instance == null)时,两个线程都判断instance为空,接下来就会得到两个实例了。这不是我们想要的单例。

接下来我们用加锁的方式来实现互斥,从而保证单例的实现。

//同步法懒汉式
public class Singleton { 

  //单例实例变量
  private static Singleton instance = null; 

  //私有化的构造方法,保证外部的类不能通过构造器来实例化
  private Singleton() {} 

  //获取单例对象实例
  public static synchronized Singleton getInstance() { 

    if (instance == null) {
      instance = new Singleton();
    } 

    System.out.println("我是同步法懒汉式单例!");
    return instance;
  }
}

加上synchronized后确实保证了线程安全,但是这样就是最好的方法吗?很显然它不是,因为这样一来每次调用getInstance()方法是都会被加锁,而我们只需要在第一次调用getInstance()的时候加锁就可以了。这显然影响了我们程序的性能。我们继续寻找更好的方法。

经过分析发现,只需要保证instance = new Singleton()是线程互斥就可以保证线程安全,所以就有了下面这个版本:

//双重锁定懒汉式
public class Singleton { 

  //单例实例变量
  private static Singleton instance = null; 

  //私有化的构造方法,保证外部的类不能通过构造器来实例化
  private Singleton() {} 

  //获取单例对象实例
  public static Singleton getInstance() {
    if (instance == null) {
      synchronized (Singleton.class) {
        if (instance == null) {
          instance = new Singleton();
        }
      }
    }
    System.out.println("我是双重锁定懒汉式单例!");
    return instance;
  }
}

这次看起来既解决了线程安全问题,又不至于每次调用getInstance()都会加锁导致降低性能。看起来是一个完美的解决方案,事实上是这样的吗?

很遗憾,事实并非我们想的那么完美。java平台内存模型中有一个叫“无序写”(out-of-order writes)的机制。正是这个机制导致了双重检查加锁方法的失效。这个问题的关键在上面代码上的第5行:instance = new Singleton(); 这行其实做了两个事情:1、调用构造方法,创建了一个实例。2、把这个实例赋值给instance这个实例变量。可问题就是,这两步jvm是不保证顺序的。也就是说。可能在调用构造方法之前,instance已经被设置为非空了。下面我们一起来分析一下:

假设有两个线程A、B

1、线程A进入getInstance()方法。
2、因为此时instance为空,所以线程A进入synchronized块。
3、线程A执行 instance = new Singleton(); 把实例变量instance设置成了非空。(注意,是在调用构造方法之前。)
4、线程A退出,线程B进入。
5、线程B检查instance是否为空,此时不为空(第三步的时候被线程A设置成了非空)。线程B返回instance的引用。(问题出现了,这时instance的引用并不是Singleton的实例,因为没有调用构造方法。)
6、线程B退出,线程A进入。
7、线程A继续调用构造方法,完成instance的初始化,再返回。

难道就没有一个好方法了吗?好的方法肯定是有的,我们继续探索!

//解决无序写问题懒汉式
public class Singleton { 

  //单例实例变量
  private static Singleton instance = null; 

  //私有化的构造方法,保证外部的类不能通过构造器来实例化
  private Singleton() {} 

  //获取单例对象实例
  public static Singleton getInstance() {
    if (instance == null) {
      synchronized (Singleton.class) {         //1
        Singleton temp = instance;        //2
        if (temp == null) {
          synchronized (Singleton.class) { //3
            temp = new Singleton();  //4
          }
          instance = temp;         //5
        }
      }
    }
    System.out.println("我是解决无序写懒汉式单例!");
    return instance;
  }
}

1、线程A进入getInstance()方法。
2、因为instance是空的 ,所以线程A进入位置//1的第一个synchronized块。
3、线程A执行位置//2的代码,把instance赋值给本地变量temp。instance为空,所以temp也为空。
4、因为temp为空,所以线程A进入位置//3的第二个synchronized块。(后来想想这个锁有点多余)
5、线程A执行位置//4的代码,把temp设置成非空,但还没有调用构造方法!(“无序写”问题)
6、如果线程A阻塞,线程B进入getInstance()方法。
7、因为instance为空,所以线程B试图进入第一个synchronized块。但由于线程A已经在里面了。所以无法进入。线程B阻塞。
8、线程A激活,继续执行位置//4的代码。调用构造方法。生成实例。
9、将temp的实例引用赋值给instance。退出两个synchronized块。返回实例。
10、线程B激活,进入第一个synchronized块。
11、线程B执行位置//2的代码,把instance实例赋值给temp本地变量。
12、线程B判断本地变量temp不为空,所以跳过if块。返回instance实例。

到此为止,上面的问题我们是解决了,但是我们突然发现为了解决线程安全问题,但给人的感觉就像身上缠了很多毛线.... 乱糟糟的,所以我们要精简一下:

//饿汉式
public class Singleton { 

  //单例变量 ,static的,在类加载时进行初始化一次,保证线程安全
  private static Singleton instance = new Singleton();   

  //私有化的构造方法,保证外部的类不能通过构造器来实例化。
  private Singleton() {} 

  //获取单例对象实例
  public static Singleton getInstance() {
    System.out.println("我是饿汉式单例!");
    return instance;
  }
}

看到上面的代码,瞬间觉得这个世界清静了。不过这种方式采用的是饿汉式的方法,就是预先声明Singleton对象,这样带来的一个缺点就是:如果构造的单例很大,构造完又迟迟不使用,会导致资源浪费。

到底有没有完美的方法呢?继续看:

//内部类实现懒汉式
public class Singleton { 

  private static class SingletonHolder{
    //单例变量
    private static Singleton instance = new Singleton();
  } 

  //私有化的构造方法,保证外部的类不能通过构造器来实例化。
  private Singleton() { 

  } 

  //获取单例对象实例
  public static Singleton getInstance() {
    System.out.println("我是内部类单例!");
    return SingletonHolder.instance;
  }
}

懒汉式(避免上面的资源浪费)、线程安全、代码简单。因为java机制规定,内部类SingletonHolder只有在getInstance()方法第一次调用的时候才会被加载(实现了lazy),而且其加载过程是线程安全的(实现线程安全)。内部类加载的时候实例化一次instance。

简单说一下上面提到的无序写,这是jvm的特性,比如声明两个变量,String a; String b; jvm可能先加载a也可能先加载b。同理,instance = new Singleton();可能在调用Singleton的构造函数之前就把instance置成了非空。这是很多人会有疑问,说还没有实例化出Singleton的一个对象,那么instance怎么就变成非空了呢?它的值现在是什么呢?想了解这个问题就要明白instance = new Singleton();这句话是怎么执行的,下面用一段伪代码向大家解释一下:

mem = allocate();       //为Singleton对象分配内存。
instance = mem;        //注意现在instance是非空的,但是还没有被初始化。 

ctorSingleton(instance);  //调用Singleton的构造函数,传递instance.

由此可见当一个线程执行到instance = mem; 时instance已为非空,如果此时另一个线程进入程序判断instance为非空,那么直接就跳转到return instance;而此时Singleton的构造方法还未调用instance,现在的值为allocate();返回的内存对象。所以第二个线程得到的不是Singleton的一个对象,而是一个内存对象。

以上就是就是我对单例模式的一点小小的思考跟理解,热烈欢迎各位大神前来指导批评。

(0)

相关推荐

  • 简单讲解在Java编程中实现设计模式中的单例模式结构

    1. 模式介绍 模式的定义 确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例. 模式的使用场景 确保某个类有且只有一个对象的场景,例如创建一个对象需要消耗的资源过多,如要访问 IO 和数据库等资源. 2. UML类图 角色介绍: (1)Client : 高层客户端. (2)Singleton : 单例类. 3. 模式的简单实现 public class Singleton { private static Singleton intance; private Singleton(

  • Java设计模式之单例模式详解

    单例模式是非常常见的设计模式,其含义也很简单,一个类给外部提供一个唯一的实例.下文所有的代码均在github 源码整个项目不仅仅有设计模式,还有其他JavaSE知识点,欢迎Star,Fork 单例模式的UML图 单例模式的关键点 通过上面的UML图,我们可以看出单例模式的特点如下: 1.构造器是私有的,不允许外部的类调用构造器 2.提供一个供外部访问的方法,该方法返回单例类的实例 如何实现单例模式 上面已经给出了单例模式的关键点,我们的实现只需要满足上面2点即可.但是正因为单例模式的实现方式比较

  • 深入解析Java的设计模式编程中单例模式的使用

    定义:确保一个类只有一个实例,而且自行实例化并向整个系统提供这个实例. 类型:创建类模式 类图: 类图知识点: 1.类图分为三部分,依次是类名.属性.方法 2.以<<开头和以>>结尾的为注释信息 3.修饰符+代表public,-代表private,#代表protected,什么都没有代表包可见. 4.带下划线的属性或方法代表是静态的. 5.对类图中对象的关系不熟悉的朋友可以参考文章:设计模式中类的关系. 单例模式应该是23种设计模式中最简单的一种模式了.它有以下几个要素: 私有的构

  • java 设计模式之单例模式

    java  设计模式之单例模式 前言: 在软件开发过程中常会有一些对象我们只需要一个,如:线程池(threadpool).缓存(cache).对话框.偏好设置等.这些对象如果制造出多个实例的话可能会导致一些不必要的麻烦,如:程序行为异常.资源使用过量等.这时单例模式就可以确保一个类只有一个实例,并提供全局访问点.下面是从简单的单例类来探讨该用何种方法实现单例模式. /** * 最经典的单例类 */ public class Singleton { // 设置成静态变量来记录Singleton的唯

  • Java设计模式之单例模式实例详解【懒汉式与饿汉式】

    本文实例讲述了Java设计模式之单例模式.分享给大家供大家参考,具体如下: 单例模式就是产生一个对象实例,供外外部访问. 它的应用场景就是在这个类在全局真资源需要统一访问,否则会造成混乱时,才有必要设计成单例. 懒汉式,就是在使用这个对象时,才去查看这个对象是否创建,如果没创建就马上创建,如果已经创建,就返回这个实例. 饿汉式,在加载这个类的时候就先创建好一个对象实例,等待调用. 两者的优缺点也能猜到,使用懒汉式,在反应速度上肯定要比饿汉式慢. 但是这个对象如果不被调用,那就节省了cpu和内存资

  • Java设计模式之单例模式实例分析

    本文实例讲述了Java设计模式之单例模式.分享给大家供大家参考,具体如下: 单例模式:(Singleton Pattern)是一个比较简单的模式,其定义如下: Ensure a class has only one instance, and provide a global point of access to it.(确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例) 单例模式,很简单的一个模式.其实在android开发中,很多地方都会用到单例模式,比如某些工具类.Json数

  • C++和java设计模式之单例模式

    单例模式(Singleton),保证一个类仅有一个实例,并提供一个访问它的全局访问点.其构造过程由自身完成,可以将构造方法定义为private型的,这样外界就只能通过定义的静态的函数Instance()构造实例,这个函数的目的就是返回一个类的实例,在此方法中去做是否有实例化的判断.客户端不再考虑是否需要去实例化的问题,把这些都交给了单例类自身.通常我们可以让一个全局变量使得一个对象被访问,但它不能防止你实例化多个对象.一个最好的办法,就是让类自身负责保存它的唯一实例.这个类可以保证没有其他实例可

  • 浅析Java设计模式编程中的单例模式和简单工厂模式

    单例模式 动机 有时候只有一个类的实例是很重要的.比如,一个系统应该只有一个窗口管理实例. 单例模式是最简单设计模式:类负责实例化自己,确保只有一个实例,并且提供一个访问这个实例的入口. 目的 1. 确保只有一个实例被创建. 2. 提供访问这个实例的入口. 使用final确保被创建一次,private的构造函数确保不被实例化.public的getInstance方法确保外部能够访问.下面是饿汉模式: public class Singleton { private static final Si

  • java设计模式之单例模式的详解及优点

    java设计模式之单例模式 定义:如果一个类始终只能创建一个实例,那么这个类被称为单例类,这种设计模式被称为单例模式. Spring框架里面可以将所有生成的bean对象都设置为单例模式,只需要在配置Bean实例时指定scope="singleton"即可,或者不做配置默认即为单例模式. 我们可以创建一个小的Demo来演示单例模式的实现,只需要保证该类只能创建一个实例,我们可以用权限修饰符private修饰该类的构造器. 提供一个创建该类的接口,该接口只能用static修饰,类里面创建一

  • java设计模式之单例模式学习

    1 概述 单例模式有几个好处: (1)某些类创建比较频繁,对于一些大型的对象,这是一笔很大的系统开销. (2)省去了new操作符,降低了系统内存的使用频率,减轻GC压力. (3)有些类如交易所的核心交易引擎,控制着交易流程,如果该类可以创建多个的话,系统完全乱了. 2 详解 单例模式常用的写法有如下这么两种. 2.1 饿汉式 如果应用程序总是创建并使用单例模式,或者在创建和运行时压力不是很大的情况下,可以使用一个私有静态变量,提前把对象创建好. 复制代码 代码如下: package org.sc

随机推荐