Java单例模式深入详解

喜欢ヅ旅行 2022-07-16 23:50 193阅读 0赞

一.问题引入  
       偶然想想到的如果把Java的构造方法弄成private，那里面的成员属性是不是只有通过static来访问呢；如果构造方法是private的话，那么有什么好处呢；如果构造方法是private的话，会不更好的封装该类呢？构造函数弄成private 就是单例模式，即不想让别人用new 方法来创建多个对象，可以在类里面先生成一个对象，然后写一个public static方法把这个对象return出去。（eg:public 类名 getInstancd()\{return 你刚刚生成的那个类对象;\}），用static是因为你的构造函数是私有的，不能产生对象，所以只能用类名调用，所有只能是静态函数。成员变量也可以写getter/setter供外界访问的。  
  
二.单例模式概念及特点

java中单例模式是一种常见的设计模式，单例模式分三种：懒汉式单例、饿汉式单例、登记式单例三种。  
　　单例模式有一下特点：  
　　1、单例类只能有一个实例。  
　　2、单例类必须自己自己创建自己的唯一实例。  
　　3、单例类必须给所有其他对象提供这一实例。

单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。总之，选择单例模式就是为了避免不一致状态，避免政出多头。

正是由于这个特 点，单例对象通常作为程序中的存放配置信息的载体，因为它能保证其他对象读到一致的信息。例如在某个服务器程序中，该服务器的配置信息可能存放在数据库或 文件中，这些配置数据由某个单例对象统一读取，服务进程中的其他对象如果要获取这些配置信息，只需访问该单例对象即可。这种方式极大地简化了在复杂环境 下，尤其是多线程环境下的配置管理，但是随着应用场景的不同，也可能带来一些同步问题。

三.典型例题  
实例：  
public class TestStream \{  
     private String name;  
     public String getName() \{  
         return name;  
     \}  
     public void setName(String name) \{  
         this.name = name;  
     \}  
     //该类只能有一个实例  
     private TestStream()\{\}    //私有无参构造方法  
     //该类必须自行创建  
     //有2种方式  
     /\*private static final TestStream ts=new TestStream();\*/  
     private static TestStream ts1=null;  
     //这个类必须自动向整个系统提供这个实例对象  
     public static TestStream getTest()\{  
         if(ts1==null)\{  
             ts1=new TestStream();  
         \}  
         return ts1;  
     \}  
     public void getInfo()\{  
         System.out.println("output message "+name);  
     \}  
 \}  
  
public class TestMain \{  
     public static void main(String \[\] args)\{  
         TestStream s=TestStream.getTest();  
         s.setName("张孝祥");  
         System.out.println(s.getName());  
         TestStream s1=TestStream.getTest();  
         s1.setName("张孝祥");  
         System.out.println(s1.getName());  
         s.getInfo();  
         s1.getInfo();  
         if(s==s1)\{  
             System.out.println("创建的是同一个实例");  
         \}else if(s!=s1)\{  
             System.out.println("创建的不是同一个实例");  
         \}else\{  
             System.out.println("application error");  
         \}  
     \}  
 \}  
//懒汉式:  
public class Singleton \{  
    private static Singleton uniqueInstance = null;  
    private Singleton() \{  
       //类外就不能调用,private是只允许同一个类里面方法使用  
    \}  
    public static Singleton getInstance() \{  
       if (uniqueInstance == null) \{  
           uniqueInstance = new Singleton();  
       \}  
       return uniqueInstance;  
    \}  
    // Other methods...  
\}    
//饿汉式:  
 public class Singleton \{  
    private static Singleton singleton= new Singleton();  
    private Singleton() \{  
       //类外就不能调用,private是只允许同一个类里面方法使用  
    \}  
    public static Singleton getInstance() \{  
       return singleton;  
    \}  
    // Other methods...  
\}

共同：Singleton通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问。  
比较：  
    1、饿汉式是线程安全的,在类创建的同时就已经创建好一个静态的对象供系统使用,以后不在改变  
    2、懒汉式如果在创建实例对象时不加上synchronized则会导致对对象的访问不是线程安全的  
          推荐使用第一种

从实现方式来讲他们最大的区别就是懒汉式是延时加载,他是在需要的时候才创建对象,而饿汉式在虚拟机启动的时候就会创建,

饿汉式无需关注多线程问题、写法简单明了、能用则用。但是它是加载类时创建实例（上面有个朋友写错了）、所以如果是一个工厂模式、缓存了很多实例、那么就得考虑效率问题，因为这个类一加载则把所有实例不管用不用一块创建。  
懒汉式的优点是延时加载、缺点是应该用同步（想改进的话现在还是不可能，比如double-check）、其实也可以不用同步、看你的需求了，多创建一两个无引用的废对象其实也没什么大不了  
  
 懒汉式实现没有考虑线程安全问题。所谓线程安全是指：如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。或者说：一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题。显然以上实现并不满足线程安全的要求，在并发环境下很可能出现多个Singleton实例

四.单例对象作配置信息管理时可能会带来的几个同步问题

1.在多线程环境下，单例对象的同步问题主要体现在两个方面，单例对象的初始化和单例对象的属性更新。

本文描述的方法有如下假设：

a. 单例对象的属性（或成员变量）的获取，是通过单例对象的初始化实现的。也就是说，在单例对象初始化时，会从文件或数据库中读取最新的配置信息。

b. 其他对象不能直接改变单例对象的属性，单例对象属性的变化来源于配置文件或配置数据库数据的变化。

1.1单例对象的初始化

首先，讨论一下单例对象的初始化同步。单例模式的通常处理方式是，在对象中有一个静态成员变量，其类型就是单例类型本身；如果该变量为null，则创建该单例类型的对象，并将该变量指向这个对象；如果该变量不为null，则直接使用该变量。

这种处理方式在单线程的模式下可以很好的运行；但是在多线程模式下，可能产生问题。如果第一个线程发现成员变量为null，准备创建对象；这是第二 个线程同时也发现成员变量为null，也会创建新对象。这就会造成在一个JVM中有多个单例类型的实例。如果这个单例类型的成员变量在运行过程中变化，会 造成多个单例类型实例的不一致，产生一些很奇怪的现象。例如，某服务进程通过检查单例对象的某个属性来停止多个线程服务，如果存在多个单例对象的实例，就 会造成部分线程服务停止，部分线程服务不能停止的情况。

1.2单例对象的属性更新

通常，为了实现配置信息的实时更新，会有一个线程不停检测配置文件或配置数据库的内容，一旦发现变化，就更新到单例对象的属性中。在更新这些信 息的时候，很可能还会有其他线程正在读取这些信息，造成意想不到的后果。还是以通过单例对象属性停止线程服务为例，如果更新属性时读写不同步，可能访问该 属性时这个属性正好为空（null），程序就会抛出异常。

下面是解决方法

//单例对象的初始化同步  
public class GlobalConfig \{  
    private static GlobalConfig instance = null;  
    private Vector properties = null;  
    private GlobalConfig() \{  
      //Load configuration information from DB or file  
      //Set values for properties  
    \}  
    private static synchronized void syncInit() \{  
      if (instance == null) \{  
        instance = new GlobalConfig();  
      \}  
    \}  
    public static GlobalConfig getInstance() \{  
      if (instance == null) \{  
        syncInit();  
      \}  
      return instance;  
    \}  
    public Vector getProperties() \{  
      return properties;  
    \}  
  \}

这种处理方式虽然引入了同步代码，但是因为这段同步代码只会在最开始的时候执行一次或多次，所以对整个系统的性能不会有影响。

单例对象的属性更新同步。

参照读者/写者的处理方式，设置一个读计数器，每次读取配置信息前，将计数器加1，读完后将计数器减1.只有在读计数器为0时，才能更新数据，同时要阻塞所有读属性的调用。

代码如下：

public class GlobalConfig \{  
 private static GlobalConfig instance;  
 private Vector properties = null;  
 private boolean isUpdating = false;  
 private int readCount = 0;  
 private GlobalConfig() \{  
   //Load configuration information from DB or file  
      //Set values for properties  
 \}  
 private static synchronized void syncInit() \{  
  if (instance == null) \{  
   instance = new GlobalConfig();  
  \}  
 \}  
 public static GlobalConfig getInstance() \{  
  if (instance==null) \{  
   syncInit();  
  \}  
  return instance;  
 \}  
 public synchronized void update(String p\_data) \{  
  syncUpdateIn();  
  //Update properties  
 \}  
 private synchronized void syncUpdateIn() \{  
  while (readCount > 0) \{  
   try \{  
    wait();  
   \} catch (Exception e) \{  
   \}  
  \}  
 \}  
 private synchronized void syncReadIn() \{  
  readCount++;  
 \}  
 private synchronized void syncReadOut() \{  
  readCount--;  
  notifyAll();  
 \}  
 public Vector getProperties() \{  
  syncReadIn();  
  //Process data  
  syncReadOut();  
  return properties;  
 \}  
  \}

采用"影子实例"的办法具体说，就是在更新属性时，直接生成另一个单例对象实例，这个新生成的单例对象实例将从数据库或文件中读取最新的配置信息；然后将这些配置信息直接赋值给旧单例对象的属性。

public class GlobalConfig \{  
    private static GlobalConfig instance = null;  
    private Vector properties = null;  
    private GlobalConfig() \{  
      //Load configuration information from DB or file  
      //Set values for properties  
    \}  
    private static synchronized void syncInit() \{  
      if (instance = null) \{  
        instance = new GlobalConfig();  
      \}  
    \}  
    public static GlobalConfig getInstance() \{  
      if (instance = null) \{  
        syncInit();  
      \}  
      return instance;  
    \}  
    public Vector getProperties() \{  
      return properties;  
    \}  
    public void updateProperties() \{  
      //Load updated configuration information by new a GlobalConfig object  
      GlobalConfig shadow = new GlobalConfig();  
      properties = shadow.getProperties();  
    \}  
  \}

注意：在更新方法中，通过生成新的GlobalConfig的实例，从文件或数据库中得到最新配置信息，并存放到properties属性中。上面两个方法比较起来，第二个方法更好，首先，编程更简单；其次，没有那么多的同步操作，对性能的影响也不大。