单例模式

     单例的意思是有一些对象，我们只需一个，多个会造成资源浪费或者无法实施：比如，线程池、缓存、对话框等，这类对象若制造多个实例，会导致许多问题出现。

      要想单例模式，可以在类内部声明一个静态方法，这个方法就是专门用来返回对象的，想要返回一个，就可以通过null判断的方式来实现，代码如下：      

ex1：

public class MyAngle {
    
    private MyAngle angle;
    
    public static MyAngle getMyAngle() {
        if (angle == null) {
            angle = new MyAngle();
        }
        return angle;
    }
}

      大家可以看到，通过getMyAngle方法就可以返回一个MyAngle，而且每次调用该方法都会返回同一个对象（我唯一的天使）。

      这样是不是就ok了？NO！NO！NO！上面的代码虽然通过getMyAngle方法可以返回同一个对象，但是它并不是new对象的唯一入口。我们以java语言为例，所有类都有构造方法，若没有主动实现则系统会默认生成一个空的构造方法，若有显示定义的构造方法，默认的构造方法就会失效。我们上面的代码中没有显示定义构造方法，所以会有一个默认的空构造方法，这样，外部系统通过new MyAngle就可以产生多个天使对象，这样就不算是单例模式。

      因此，通过上面的分析，我们明白了，要让getMyAngle方法成为Myangle对象的唯一制造者，即把构造方法私有化就可以达到目的。单例模式的定义也是这样的：保证一个类仅有一个实例，并提供一个访问它的全局访问点。如下：

ex2：

public class MyAngle {

    private MyAngle angle;
    
    private MyAngle(){}

    public static MyAngle getMyAngle() {
        if (angle == null) {
            angle = new MyAngle();
        }
        return angle;
    }
}

    通过上面的代码可以看出，我们只能通过getMyAngle方法获得MyAngle的对象，并且重复调用该方法返回的是同一个对象。

    还有一种单例模式如下：

ex3：

public class MyAngle {

    private static MyAngle angle = new MyAngle();

    private MyAngle(){}

    public static MyAngle getMyAngle() {
        
        return angle;
    }
}

     ex2和ex3的实现方式有什么区别呢？通过对比可以看出来，ex2中getMyAngle方法第一次被调用的时候才会new出来对象，而ex3是通过静态初始化的方式实现的，在类加载的时候就会new出来MyAngle对象，被形象地成为饿汉式单例类，而ex2被称为懒汉式单例类。

      饿汉式是静态初始化的方式，在类一加载就实例化的对象，所以要提前占用系统资源；而懒汉式是在被调用的时候实例化对象，但它会面临多线程访问的安全性问题，接下来，我们来探讨多线程中的单例模式。

      在多线程的程序中，若多个线程同时访问MyAngle的getMyAngle方法，有可能会造成创建多个实例。比如，线程A调用getMyAngle方法，判断了angle == null，此时CPU的执行机会给了线程B，线程B也判断了angle == null，然后cpu的执行机会给了线程A，线程A就实例化了一个MyAngle对象，然后线程B获得Cpu执行机会，这时候，线程B已经判断了angle为null，并不知道线程A已经实例化了一个Angle对象，因此，又实例化了一个Angle对象，这样就出现了多个实例，破坏了单例模式。

     为了解决这一问题，我们可以给getMyAngle方法加锁，如下：

ex4：

public class MyAngle {

    private MyAngle angle;

    private MyAngle(){}

    public static synchronized MyAngle getMyAngle() {

        if (angle == null) {
            angle = new MyAngle();
        }
        return angle;
    }
}

    这样给方法加synchronized关键字就可以保证不会有两个线程同时进入该方法，也只会实例化一个对象。这样确实是完成了我们的使命，但是对于单例模式来说，只有第一次执行的时候，才真正需要同步，之后每次调用这个方法，同步就是一种累赘，这样就会造成严重的性能问题。

     下面我们使用一种更优秀的同步方法：

ex5:

public class MyAngle {

    private MyAngle angle;
    
    private static Object obj = new Object();

    private MyAngle(){}

    public static MyAngle getMyAngle() {
        
        
        if (angle == null) {
            lock(obj){
                if (angle == null){
                    angle = new MyAngle();
                }
            }
        }
        return angle;
    }
}

    上面的代码是让锁的粒度更小，不用让线程每次都加锁，而只是在实例未被创建的时候再加锁处理。可以看到，在锁前和锁后经过了两次null判断，这种做法叫双重检查锁定机制（Double-Check Locking）。为什么要两次null判断呢？锁放在第一个null判断后面，每一个线程执行要第一个if判断都不会被阻塞，angle不为null，就可以直接返回实例，只有对象没有实例化的时候，才会进入同步块。现在假如对象还没有实例化，有两个线程都执行了第一个if判断，需要进入同步块，但是同步块中只能有一个进入，另一个在外排队等候，必须要其中一个进入并出来后，另一个才能进入。而此时如果没有第二重的判断，则第一个线程创建了实例，而第二个线程还是可以继续再创建新的实例，这就没有达到单例的目的了。

      以上就是单例模式的基本内容，算是相对比较简单的一种模式，相信读者读完文章后会对单例模式有更深刻的理解。