剑指Offer Java实现 - 单例模式饿汉式懒汉式双重校验内部静态类

ゞ浴缸里的玫瑰 2022-12-27 06:28 149阅读 0赞

###  剑指Offer Java实现 - 单例模式 饿汉式 懒汉式 双重校验 内部静态类 ###

#### 单例模式 ####

*  单例模式可以说是Java设计模式中最简单的一个了，它属于创建型模式。单例模式只涉及到一个单一的类，其中心思想就是由该类负责创建自己的对象，并确保只有单个对象被创建，同时向全局提供一个获取该单一对象的入口。总的来说，这个类需要提供一种访问其唯一对象的方式，且不需要实例化该类的对象，直接访问即可。
 *  可以总结出以下几点：
    
     *  单例类只能有一个实例对象；
     *  单例类需要自己完成其唯一实例的创建；
     *  单例类需要向全局提供一个访问其实例的入口。

#### 关键思路 ####

*  要做到一个类的实例只能由类自身进行创建，关键就是私有化其构造函数。且在该类内部，需要实现单例创建与否的判断，根据判断的结果，如果有则直接返回，如果没有则创建之后返回。
 *  单例模式主要是应用在需要控制实例数量，节省系统资源的场景下。而其优点相应的就是减少了内存的开销，尤其是在频繁的创建和销毁实例的时候。但是它也有缺点，比如它就与单一职责原则冲突了，一个类只应该关心其内部逻辑的实现，而不应该插手外部对其的实例化。

#### 代码实现 ####

*  单例模式的代码实现其实很简单，关键点就是私有化其构造函数。但是结合不同的场景需求（单线程多线程）以及Java的特性（锁和类加载），就会有很多种实现方法，我这里总结了常见的五种。
 *  1） 饿汉式
    
     *  饿汉式实现起来简单，它基于类加载机制，不用加锁也能避免多线程同步的问题，所以执行效率会比较高。但是这种方法有个缺点，就是在类加载的时候就会进行实例化，没有达到Lazy Loading的效果。该种方法的代码实现如下：
    
        public class Singleton1 { 
        
            private Singleton1() { 
        
            }
        
            private static final Singleton1 instance = new Singleton1();
        
            public static Singleton1 getInstance() { 
                return instance;
            }
        
        }
 *  2）懒汉式（线程不安全）
    
     *  针对饿汉式中没有Lazy Loading的效果，可以通过如下方法来实现。不过该方法也有个最大的问题，就是只能支持在单线程环境下工作，它是线程不安全的，多线程的话会出现多个实例化对象的出现。具体代码如下：
    
        public class Singleton2 { 
        
            private Singleton2() { 
        
            }
        
            private static Singleton2 instance;
        
            public static Singleton2 getInstance() { 
                if (instance == null) { 
                    instance = new Singleton2();
                }
                return instance;
            }
        
        }
 *  3）懒汉式（线程安全）
    
     *  针对线程不安全的问题，最简单直接的解决方法就是加锁，对getInstance( )方法加锁，这能很快的解决多线程安全问题，但是带来的问题也很明显，就是太影响性能了。具体代码如下所示：
    
        public class Singleton3 { 
        
            private Singleton3() { 
        
            }
        
            private static Singleton3 instance;
        
            synchronized public static Singleton3 getInstance() { 
                if (instance == null) { 
                    instance = new Singleton3();
                }
                return instance;
            }
        
        }
 *  4）双重校验锁（double-checked locking）
    
     *  直接对整个getInstance( )方法上锁，能够解决线程安全问题，但会大大影响程序的性能，因为很容易出现锁竞争的情况。这里使用双重校验的机制，一方面能够解决线程安全问题，另一方面还能保持高性能。关键就是在于两个if判断，其实大部分情况下外部的if判断是不会通过的，因为只要该单例类被实例化了一次，外部if的判断条件就成立不了了，所以能够保持较好的性能；而内部的if判断，则针对的是单例类还没被实例化的时候，可能有多个线程同时通过了外部的if判断，要对单例类进行实例化，此时就需要上锁，并在临界区内再次判断实例是否已经被创建，防止多次创建，因此内部的if判断保证了只有一个实例会被创建。具体代码如下：
    
        public class Singleton4 { 
        
            private Singleton4() { 
        
            }
        
            private static Singleton4 instance;
        
            public static Singleton4 getInstance() { 
                if (instance == null) { 
                    synchronized (Singleton4.class) { 
                        if (instance == null) { 
                            instance = new Singleton4();
                        }
                    }
                }
                return instance;
            }
        
        }
 *  5）静态内部类
    
     *  该方法能够达到同双重校验方式相同的效果，且实现方法更为简单，不需要借助锁就能实现。主要是借助了类加载的特性，内部静态类只有在使用的时候才会进行加载，这就能够实现Lazy Loading；且类加载时只会加载一次，天然的线程安全保证。具体代码如下：
    
        public class Singleton5 { 
        
            private Singleton5() { 
        
            }
        
            private static class InnerClass { 
                private static final Singleton5 instance = new Singleton5();
            }
        
            public static Singleton5 getInstance() { 
                return InnerClass.instance;
            }
        
        }