Java Singleton单例模式

最新推荐文章于 2024-09-09 14:08:53 发布

龙龙22

最新推荐文章于 2024-09-09 14:08:53 发布

阅读量422

点赞数

分类专栏：设计模式

设计模式专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Singleton模式

宗旨：在于确保某个类只有一个实例，并且为之提供一个全局访问点，为了防止其他工作人员实例化我们的类。

方法：为该类创建唯一一个构造器，并将构造器设置为私有。注意：如果我们创建了其他的非私有构造器，或者根本没有为该类提供构造器，那么其他人员仍然能够实例化我们的类。

通常单例模式在Java语言中，有两种构建方式：

饿汉方式:指全局的单例实例在类装载时构建，急切初始化。
懒汉方式:指全局的单例实例在第一次被使用时构建，延迟初始化。

经典事例：连接数据库时的Connection

Demo：

分别列出多种实现方式，各分析其优缺点

1）（饿汉方式）静态成员直接初始化，或者在静态代码块初始化都可以

     Java代码   
     
   
 class Singleton{    
     private Singleton(){}    
     private static final Singleton singleton = new Singleton();    
     public static Singleton getInstance(){return singleton;}    
 }    

该实现只要在一个ClassLoad下就会提供一个对象的单例。但是美中不足的是，不管该资源是否被请求，它都会创建一个对象，占用jvm内存。从lazy initialization思想出发，出现了下2的写法（缺：没有实现懒加载机制，用到时才加载，节省内存）

2.懒汉式单例类

public class Singleton2 {

private Singleton2() {

}

private static Singleton2 instance = null;

/**

* 这个方法比上面有所改进，不用每次都进行生成对象，只是第一次　　　

* 使用时生成实例，提高了效率！

* @return

public static Singleton2 getInstance() {

if (instance == null)

instance = new Singleton2();

return instance;

}

下面主要多线程问题，在懒汉单例中，单线程是没有问题的，但 多线程时就会有可能出现两个或者以上的Singletion2实例的情况 。
例如：线程1在判断instance==null为真，扫行new操作时，在执行new操作之前，判断为真之后，线程2正好执行判断操作，这时instance还为null.因此，线程2也会执行new操作。以此类推，在高并发下面，就可能存在两个或者以上的Singletion2的实例。显然，这是不正确的。

2）根据lazy initialization思想，使用到时才初始化。

     Java代码   
     
   
 class Singleton{    
     private Singleton(){}    
     private static Singleton singleton ;    
     public static synchronized Singleton getInstance(){    
         if(singleton==null)    
             singleton = new Singleton();    
         return singleton;           
     }       
 }     

该实现方法加了同步锁，可以有效防止多线程在执行getInstance方法得到2个对象。

缺点：只有在第一次调用的时候，才会出现生成2个对象，才必须要求同步。而一旦singleton 不为null，系统依旧花费同步锁开销，有点得不偿失。因此再改进出现写法3

3）在2的基础上改进，改进标准：尽量减少锁资源(主要体现在执行时间，所占内存等)

     Java代码   
     
   
 class Singleton{    
     private Singleton(){}    
     private static Singleton singleton ;    
     public static Singleton getInstance(){    
         if(singleton==null)//1    
             synchronized(Singleton.class){//2    
                 singleton = new Singleton();//3    
             }    
         return singleton;           
     }       
 }    

这种写法减少了锁开销，但是在如下情况，却创建了2个对象：

a:线程1执行到1挂起，线程1认为singleton为null

b:线程2执行到1挂起，线程2认为singleton为null

c:线程1被唤醒执行synchronized块代码，走完创建了一个对象

d:线程2被唤醒执行synchronized块代码，走完创建了另一个对象

所以看出这种写法，并不完美。

4）为了解决3存在的问题，引入双重检查锁定

     Java代码   
     
   
 public static Singleton getInstance(){    
         if(singleton==null)//1    
             synchronized(Singleton.class){//2    
                 if(singleton==null)//3    
                     singleton = new Singleton();//4    
             }    
         return singleton;           
     }    

在同步锁代码块内部，再判断一次对象是否为null，为null才创建对象。这种写法已经接近完美：

a:线程1执行到1，已经进入synchronized的时候，线程挂起，线程1占有Singleton.class资源锁；

b:线程2执行到1，当它准备synchronized块时，因为Singleton.class被占用，线程2阻塞；

c:线程1被唤醒，判断出对象为null，执行完创建一个对象

d:线程2被唤醒，判断出对象不为null，不执行创建语句

如此分析，发现似乎没问题。

但是实际上并不能保证它在单处理器或多处理器上正确运行；

问题就出现在singleton = new Singleton()这一行代码。它可以简单的分成如下三个步骤：

mem= singleton();//1

instance = mem;//2

ctorSingleton(instance);//3

这行代码先在内存开辟空间，赋给singleton的引用，然后执行new 初始化数据，但是注意初始化是要消耗时间。如果此时线程3在执行步骤1的时候，发现singleton 为非null，就直接返回，那么线程3返回的其实是一个没构造完成的对象。

我们期望1,2,3 按照反序执行，但是实际jvm内存模型，并没有明确的有序指定。

这归咎于java的平台的内存模型允许“无序写入”。

如果我们既想使用延迟加载的好处，让类在被使用的时候才去加载，又想避免额外的同步调用开销，同时还不使用双重检查的模式，可以用初始化一个中间的容器类来解决这个问题，就可以用如下的写法：

      Java代码   
      
    
 public class Singleton {  
     private static class SingletonHolder {  
         static Singleton instance = new Singleton();  
     }  
   
     public static Singleton getInstance() {  
         return SingletonHolder.instance;  
     }  
   
     private Singleton() {  
     }  
 }  