单件模式

来源：互联网发布：软件项目描述编辑：程序博客网时间：2024/05/03 12:38

有人说单件模式是最简单的模式，因为它只有一个类，但其实它还有一些值得注意的地方，就如：出现并发性时，单件可能已经不是单件了。

先说一下，我们为什么要用到单件模式，当我们用到这些对象如：线程池，缓存，注册表和日志对象等，事实上，这些对象我们只能有一个实例，不然会导致很多问题出现，所以我们要将它弄成单件的。

可能你会说利用程序员之间的约定或是利用全局变量就可以做到啊，如：java的静态变量。是的，但全局变量有一个缺点，就是它必须在程序一开始就要创建好，万一这个对象非常耗费资源，而程序又一直没用到它，那不是很浪费吗？而单件模式就克服了这个缺点。

到底如何实现这个单件模式呢？首先这个类只能实例化一次，那就说明它的构造方法不能公开；那不公开，我又如何实例化它呢？其实我们可以这样子做：(这种是经典的单件模式实现)

[java] view plaincopyprint?
public class Singleton {  
    private static Singleton uniqueInstance;//利用一个静态变量来记录Singleton类的唯一实例  
   
    // other useful instance variables here  
   
    private Singleton() {}//只有自己才能调用构造器  
   
    public static Singleton getInstance() {  
                //断点1（为下面文字解析使用）  
        if (uniqueInstance == null) {  
                 //断点2  
            uniqueInstance = new Singleton();//当uniqueInstance不存在时才创建  
        }  
        return uniqueInstance;  
    }  
   
    // other useful methods here  
}  

如果你以为这样已经完美了，那就太天真了。在一个单线程中运行，这样确实已经完美了，但如果有很多个线程并发的情况下，那单件可能就不是单件了。

如：现在有两个线程A和B，当单件类还没实例化时，A和B线程都执行到断点1，因为单件类还没实例化，所以都可以执行断点2，当A这时先实例化单件类，虽然这时已经实例化单件类了，但这时已经不能阻止线程B再次执行实例化了（因为这时B已经进来了），这时就存在2个实例了，所以这种经典的单件模式实现有点瑕疵。

对于如何处理多线程的问题，我这有三种解决方法。

第一种：

[java] view plaincopyprint?
public class Singleton {  
    private static Singleton uniqueInstance;  
   
    // other useful instance variables here  
   
    private Singleton() {}  
   
    public static synchronized Singleton getInstance() {//比上面的代码中多了一个synchronized   
        if (uniqueInstance == null) {  
            uniqueInstance = new Singleton();  
        }  
        return uniqueInstance;  
    }  
   
    // other useful methods here  
}  

没错，就是加线程锁来解决，要求进入getInstance()方法前，要等候别的线程离开该方法，才能执行，就是所不存在两个或以上的线程同时进入这个方法。但其实我们只有第一次执行此方法时才真正需要同步，创建好uniqueInstance变量后，我们就不需要同步这个方法了，而同步会降低性能，是一种累赘。

第二种：

[java] view plaincopyprint?
public class Singleton {  
      
        //在静态初始化器中创建单件，保证了线程安全  
        private static Singleton uniqueInstance = new Singleton();  
  
    private Singleton() {}  
   
    public static Singleton getInstance() {  
        return uniqueInstance;  
    }  
}  

这种就是一开始就创建好单件类，而不用延迟实例化的做法，如果创建和运行这个单件类时，负担不太繁重，就可以利用这种方法创建单件，毕竟简单好用嘛。

第三种：（我认为最好的一种，不过需要java 5及以上版本才能使用）

[java] view plaincopyprint?
public class Singleton {  
    private volatile static Singleton uniqueInstance;  
   
    private Singleton() {}  
   
    public static Singleton getInstance() {  
                //断点1  
        if (uniqueInstance == null) {  
                  //断点2  
            synchronized (Singleton.class) {  
                         //断点3  
                if (uniqueInstance == null) {  
                              //断点4  
                    uniqueInstance = new Singleton();  
                }  
            }  
        }  
        return uniqueInstance;  
    }  
}  

首先解析volatile这个是有什么用的：用在多线程，同步变量。线程为了提高效率，将某成员变量(如A)拷贝了一份（如B），线程中对A的访问其实访问的是B。只在某些动作时才进行A和B的同步。因此存在A和B不一致的情况。volatile就是用来避免这种情况的。volatile告诉jvm，它所修饰的变量不保留拷贝，直接访问主内存中的（也就是上面说的A) ，但不保证原子操作。

还是以两个线程A和B来说明，当单件类还没实例化时，线程A和B同时执行到断点1，判断完之后就会执行到断点2，这时假设A先快一步，执行到断点3并锁住类，线程B只能等待，线程A判断完后，执行断点4并实例化单件类后，离开方法解锁；线程B执行到断点3并锁住类，这时判断实例uniqueInstance已存在，离开并解锁。后面其他一些线程只会执行到断点1，并不会执行到断点2，这样就避免了线程锁所带来的性能问题了。

注意锁前锁后的判断都是必须的，锁前是避免创建实例后其他线程执行线程锁方法，提高了性能；锁后，是避免创建多个实例，不然有多少个线程进入断点2，就会产生多少个实例。

这就是“双重检查加锁”的方法。

这就是单件模式，如果对其他的一些设计模式也感兴趣，欢迎查看我其他的一些博客。

0 0