单例模式（含多线程处理）

版权声明：本文为博主原创文章，转载请注明出处，欢迎交流学习！

      单例，顾名思义一个类只有一个实例。为什么要使用单例模式，或者说什么样的类可以做成单例的？在工作中我发现，使用单例模式的类都有一个共同点，那就是这个类没有状态，也就是说无论你实例化多少个对象，其实都是一样的。又或者是一个类需要频繁实例化然后销毁对象。还有很重要的一点，如果这个类有多个实例的话，会产生程序错误或者不符合业务逻辑。这种情况下，如果我们不把类做成单例，程序中就会存在多个一模一样的实例，这样会造成内存资源的浪费，而且容易产生程序错误。总结一下，判断一个类是否要做成单例，最简单的一点就是，如果这个类有多个实例会产生错误，或者在整个应用程序中，共享一份资源。

     在实际开发中，一些资源管理器、数据库连接等常常设计成单例模式，避免实例重复创建。实现单例有几种常用的方式，下面我们来探讨一下他们各自的优劣。

     第一种方式：懒汉式单例

     

public class Singleton {
    //一个静态实例
    private static Singleton singleton;
    //私有构造方法
    private Singleton(){
        
    }
    //提供一个公共静态方法来获取一个实例
    public static Singleton getInstance(){
        
        if(singleton == null ){
            
            singleton = new Singleton();
        }
        
        return singleton;
        
    }
}

 

    在不考虑并发的情况下，这是标准的单例构造方式，它通过以下几个要点来保证我们获得的实例是单一的。

    1、静态实例，静态的属性在内存中是唯一的；

    2、私有的构造方法，这就保证了不能人为的去调用构造方法来生成一个实例；

    3、提供公共的静态方法来返回一个实例， 把这个方法设置为静态的是有原因的，因为这样我们可以通过类名来直接调用此方法（此时我们还没有获得实例，无法通过实例来调用方法），而非静态的方法必须通过实例来调用，因此这里我们要把它声明为静态的方法通过类名来调用；

    4、判断只有持有的静态实例为null时才通过构造方法产生一个实例，否则直接返回。

    在多线程环境下，这种方式是不安全，通过自己的测试，多个线程同时访问它可能生成不止一个实例，我们通过程序来验证这个问题：

    

public class Singleton {
    //一个静态实例
    private static Singleton singleton;
    //私有构造方法
    private Singleton(){
        
    }
    //提供一个公共静态方法来获取一个实例
    public static Singleton getInstance(){
        
        if(singleton == null ){
            
            try {
                Thread.sleep(5000);  //模拟线程在这里发生阻塞
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
            singleton = new Singleton();
        }
        
        return singleton;
        
    }
}

    测试类：

public class TestSingleton {
    
    public static void main(String[] args) {
        
        Thread t1 = new MyThread();
        Thread t2 = new MyThread();
        
        t1.start();
        t2.start();
    }

}


class MyThread extends Thread{
    
    @Override
    public void run() {
        
        System.out.println(Singleton.getInstance()); //打印生成的实例，会输出实例的类名+哈希码值
        
    }
}

    执行该测试类，输出的结果如下：

    

    从以上结果可以看出，输出两个实例并且实例的hashcode值不相同，证明了我们获得了两个不一样的实例。这是什么原因呢？我们生成了两个线程同时访问getInstance()方法，在程序中我让线程睡眠了5秒，是为了模拟线程在此处发生阻塞，当第一个线程t1进入getInstance()方法，判断完singleton为null，接着进入if语句准备创建实例，同时在t1创建实例之前，另一个线程t2也进入getInstance()方法，此时判断singleton也为null，因此线程t2也会进入if语句准备创建实例，这样问题就来了，有两个线程都进入了if语句创建实例，这样就产生了两个实例。

    为了避免这个问题，在多线程情况下我们要考虑线程同步问题了，最简单的方式当然是下面这种方式，直接让整个方法同步：

    

public class Singleton {
    //一个静态实例
    private static Singleton singleton;
    //私有构造方法
    private Singleton(){
        
    }
    //提供一个公共静态方法来获取一个实例
    public static synchronized Singleton getInstance(){
        
        if(singleton == null ){
            
            try {
                Thread.sleep(5000);  //模拟线程在这里发生阻塞
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
            singleton = new Singleton();
        }
        
        return singleton;
        
    }
}

    我们通过给getInstance()方法加synchronized关键字来让整个方法同步，我们同样可以执行上面给出的测试类来进行测试，打印结果如下：

    

    从测试结果可以看出，两次调用getInstance()方法返回的是同一个实例，这就达到了我们单例的目的。这种方式虽然解决了多线程同步问题，但是并不推荐采用这种设计，因为没有必要对整个方法进行同步，这样会大大增加线程等待的时间，降低程序的性能。我们需要对这种设计进行优化，这就是我们下面要讨论的第二种实现方式。

    第二种方式：双重校验锁

    由于对整个方法加锁的设计效率太低，我们对这种方式进行优化：

    

public class Singleton {
    //一个静态实例
    private static Singleton singleton;
    //私有构造方法
    private Singleton(){
        
    }
    //提供一个公共静态方法来获取一个实例
    public static Singleton getInstance(){
        
        if(singleton == null ){
            
            synchronized(Singleton.class){
                
                if(singleton == null){
                    
                    singleton = new Singleton();
                    
                }
            }
        }
        
        return singleton;
        
    }
}

    跟上面那种糟糕的设计相比，这种方式就好太多了。因为这里只有当singleton为null时才进行同步，当实例已经存在时直接返回，这样就节省了无谓的等待时间，提高了效率。注意在同步块中，我们再次判断了singleton是否为空，下面解释下为什么要这么做。假设我们去掉这个判断条件，有这样一种情况，当两个线程同时进入if语句，第一个线程t1获得线程锁执行实例创建语句并返回一个实例，接着第二个线程t2获得线程锁，如果这里没有实例是否为空的判断条件，t2也会执行下面的语句返回另一个实例，这样就产生了多个实例。因此这里必须要判断实例是否为空，如果已经存在就直接返回，不会再去创建实例了。这种方式既保证了线程安全，也改善了程序的执行效率。

    第三种方式：静态内部类

    

public class Singleton {
    //静态内部类
    private static class SingletonHolder{
        private static Singleton singleton = new Singleton();
    }
    //私有构造方法
    private Singleton(){
        
    }
    //提供一个公共静态方法来获取一个实例
    public static Singleton getInstance(){
        
        return SingletonHolder.singleton;
        
    }
}

    这种方式利用了JVM的类加载机制，保证了多线程环境下只会生成一个实例。当某个线程访问getInstance()方法时，执行语句访问内部类SingletonHolder的静态属性singleton，这也就是说当前类主动使用了改静态属性，JVM会加载内部类并初始化内部类的静态属性singleton，在这个初始化过程中，其他的线程是无法访问该静态变量的，这是JVM内部帮我们做的同步，我们无须担心多线程问题，并且这个静态属性只会初始化一次，因此singleton是单例的。

    第四种方式：饿汉式

    

public class Singleton {
    //一个静态实例
    private static Singleton singleton = new Singleton();
    //私有构造方法
    private Singleton(){
        
    }
    //提供一个公共静态方法来获取一个实例
    public static Singleton getInstance(){
        
        return singleton;
        
    }
}

    这种方式也是利用了JVM的类加载机制，在单例类被加载时就初始化一个静态实例，因此这种方式也是线程安全的。这种方式存在的问题就是，一旦Singleton类被加载就会产生一个静态实例，而类被加载的原因有很多种，事实上我们可能从始至终都没有使用这个实例，这样会造成内存的浪费。在实际开发中，这个问题影响不大。

    以上内容介绍了几种常见的单例模式的实现方式，分析了在多线程情况下的处理方式， 在工作中可根据实际需要选择合适的实现方式。还有一种利用枚举来实现单例的方式，在工作中很少有人这样写过，不做探讨。