单例模式

---

一.单例模式介绍

单例模式是Java二十三种设计模式中的一种，也是一种比较常用的设计模式。其作用是保证该类只能拥有一个实例对象。

二.实现步骤

1.私有化该类的构造方法，让其他类无法通过构造器创建该类的实例。
2.提供可以获取到该类实例的静态方法，让其他类通过该方法获取到该类的实例。

三.写法介绍

1.饿汉式

1.1 介绍

因为该类的实例是在类加载的时候就创建出来的，并不是在使用的时候。就像被饿了很久的人见到吃的，不管三七二十一，先填饱肚子再说。所以把这种写法叫做饿汉式。

1.2 Java代码

    public class Test{
        //本类持有本类的引用
        private static Test mInstance = new Test();
        
        //将构造方法私有化
        private Test(){
        
        }
        
        //提供一个对外的方法获取本类的引用
        public static Test getInstance(){
            return mInstance;
        }
    }

1.3 优缺点

优点：写法简单，线程安全，避免了线程同步的问题。
缺点：因为实例是在类加载的时候初始化，所以它的生命周期是和类相同。即使它从未被用到，也不会被系统回收，造成内存的浪费。
可以但是不推荐使用饿汉式。

2.懒汉式（基本写法）

2.1 介绍

该写法是只有在使用的时候才进行实例创建。就像一个懒汉只有当饿了的时候才去吃饭。

2.2 Java代码

    public class Test{
        private static Test mInstance;
        
        private Test(){
        }
        
        public static Test getInstance(){
            if(null = mInstance){
                mInstance = new Test();
            }
            return mInstance;
        }
    }

2.3 优缺点

优点：当使用的时候才进行实例化，不会造成内存的浪费。起到了Lazy Loading的效果。
缺点：在单线程该写法没有问题。但是在多线程情况下，是线程不安全的。
不推荐使用该写法。

3.懒汉式（同步方法）

3.1 介绍

为了解决懒汉式的线程不安全问题，把getInstance()方法进行线程同步。

3.2 Java代码

    public class Test{
        private static Test mInstance;
        
        private Test(){
        
        }
        
        public static synchronized Test getInstance(){
            if(null == mInstance){
                mInstance = new Test();
            }
            return mInstance;
        }
    
    }

*3.3 优缺点

优点：解决了线程安全问题。
缺点：同步效率低。每次调用getInstance方法时都要进行同步。但实际上只有当mInstance == null时才有同步的必要，不为null时直接return就OK了。
不推荐使用。

4.懒汉式（同步代码块）

4.1 介绍

为了解决同步方法效率低而产生的写法。

4.2 代码

    public class Test{
        private static Test mInstance;
        
        private Test(){
        
        }
        
        public static Test getInstance(){
            if(null == mInstance){
                synchronized(Test.class){
                    mInstance = new Test();
                }
            }
            return mInstance;
        }
        
    }

4.3 优缺点

和传统的懒汉式基本没区别。都是线程不安全。
不推荐使用。

5.懒汉式（双重检查）

5.1 介绍

在同步方法的基础上再进行改良的。

5.2

    public class Test{
        private static volatile Test mInstance;
        
        private Test(){
        
        }
        
        public static Test getInstance(){
            if(null == mInstance){
                synchronized(Test.class){
                    if(null == mInstance){
                        Test = new Test();
                    }
                }
            }
            return mInstance;
        }
    }

5.3 优缺点

优点：这种懒汉式的写法用到了Double-Check。进行了两次非空判断，保证了线程安全，并且只实例化的一次代码。该写法线程安全，延迟加载，效率高。
缺点：无。
推荐使用。

6.静态内部类

6.1 介绍

静态内部类跟饿汉式方式采用的机制类似，但又不同。两者都是采用了类装载的机制来保证初始化实例时只有一个线程。不同的是饿汉式在类被装载时被实例化，没有Lazy Loading的作用。而静态内部类方式在类被装载时并不会实例化，而是在需要实例化时，才会调用。

6.2 代码

    public class Test{
        private Test(){
        
        }
        
        private static class SingletonInstance{
            private static final Test INSTANCE = new Test();
        }
        
        public static Test getInstance(){
            return SingletonInstance.INSTANCE;
        }
    
    }

6.3 优缺点

优点：利用类的静态属性保证唯一性，JVM保证线程安全，延迟加载，效率高。
推荐使用。

7.枚举

7.1 代码

    public enum Test{
        INSTANCE;
        public void whateverMethod(){
        
        }
    }

本文章参考了CSDN的博客，这是去往该作者的 链接.