为什么说单例模式的饿汉式是线程安全的？

妖狐艹你老母 2023-02-10 05:04 140阅读 0赞

# 一、类加载的方式是按需加载，且只加载一次 #

因此，在上述单例类被加载时，就会实例化一个对象并交给自己的引用，供系统使用。单例就是该类只能返回一个实例。

换句话说，**在线程访问单例对象之前就已经创建好了**。再加上，由于一个类在整个生命周期中只会被加载一次，因此该单例类只会创建一个实例。

也就是说，**线程每次都只能也必定只可以拿到这个唯一的对象**。即**饿汉式单例天生就是线程安全的。**

# 二、单例模式几种实现 #

## 单例模式特点 ##

**私有构造方法**private SingleTon1()  
**私有静态全局变量**private static SingleTon1 singleton = new SingleTon1()  
**公有静态方法**public static getInstance()

## instance为什么一定要是static的？ ##

> 1.通过静态的类方法（getInstance) 获取instance，该方法是静态方法，instance由该方法返回（被该方法使用），如果instance非静态，无法被getInstance调用；

> 2.instance需要在调用getInstance时候被初始化，只有static的成员才能在没有创建对象时进行初始化。且类的静态成员在类第一次被使用时初始化后就不会再被初始化，保证了单例；

> 3.static类型的instance存在静态存储区，每次调用时，都指向的同一个对象。其实存放在静态区中的是引用，而不是对象。而对象是存放在堆中的。

## 单例模式的构造方法为什么私有? ##

> 1.设置private以后，每次new对象的时候都要调用构造方法。而private的权限是当前类，那么其他类new对象的时候一定会失败。  
> 2.设置成private是考虑封装性，防止在外部类中进行初始化，也就不是单例了。

饿汉式:

//基于JVM的类加载器机制避免了多线程的同步问题，对象在类装载时就实例化
    public class SingleTon1(){ 
      private SingleTon1(){ 
      }
      private static SingleTon1 singleton = new SingleTon1();
      public static getInstance(){ 
         return singleton ;
      }
    }

懒汉式：

//能够在getInstance()时再创建对象，所以称为懒汉式。
    //这种实现最大的问题就是不支持多线程。因为没有加锁同步。
    public class SingleTon2(){ 
       private SingleTon2(){ 
       }
       private static SingleTon2 singleton2 = null;
       public static getInstance(){ 
         if(singleton2 == null){ 
    	   singleton2 = new SingleTon2();
    	 }
    	  return singleton2 ;
       }
    }

加同步锁synchronized的懒汉模式：

//除第一次使用，getInstance()需要同步,后面getInstance()不需要同步；每次同步，效率很低。
    public class SingleTon3(){ 
       private SingleTon3(){ 
       }
       private static SingleTon3 singleton3 = null;
       public synchronized static getInstance(){ 
         if(singleton3 == null){ 
    	   singleton3 = new SingleTon3();
    	 }
    	  return singleton3 ;
       }
    }

双重锁模式：

//安全且在多线程情况下能保持高性能。
    //实例变量需要加volatile 关键字保证易变可见性
    public class SingleTon4{ 
      private SingleTon4(){ 
      }
      private volatile static SingleTon4 singleton4 = null;
      public static SingleTon4 getSingleton(){ 
         if(singleton4 == null){ 
            synchronized (SingleTon4.class){ 
              if(singleton4 == null){ 
     		      singleton4 = new SingleTon3();
     		  }
    		}
    	 }
    	  return singleton4 ;
      }
    }

静态内部类模式：

//利用了JVM类加载机制来保证初始化实例对象时只有一个线程，
    //静态内部类SingletonHolder类只有第一次调用getInstance方法时，才会装载从而实例化对象
    public class Singleton5{ 
      private SingleTon5 (){ 
      }
      private static class SingletonHolder{ 
           private static final Singleton5 = new Singleton5();
      }
      public static final Singleton5 getInstance() { 
           return SingletonHolder.Singleton5 ;
      }
    }

# 三、单例模式VS静态类（静态属性/方法） #

> 把类中所有属性/方法定义成静态也可以实现"单例"。 静态类不用实例化就可以使用，虽然使用比较方便，但失去了面向对象的一些优点，适用于一些过程简单且固定、不需要扩展变化、不需要维护任何状态的类方法，如java.lang.Math，里面每种计算方法基本都是固定不变的。那为什么需要用"NEW"单例模式，而不把类中所有属性/方法定义成静态的？  
> 单例模式保证一个类对象实例的唯一性，有面向对象的特性，虽然扩展不容易，但还是可以被继承（protected权限的构造方法）、重写方法等。

# 四、Java反射攻击破坏单例模式 #

给实例构造函数protected或private权限，**可以通过相关反射方法，改变其权限，创建多个实例**。比如：

public class Test { 
         public static void main(String args[]) { 
    		    private Singleton() { };
                Singleton singleton = Singleton.getInstance();
            	try { 
                Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
                constructor.setAccessible(true);
                Singleton singletonnew = constructor.newInstance();
                System.out.println(singleton == singletonnew);
                //输出结果为 false
            } catch (Exception e) { 
     
            }     
        }
    }

**解决方案**：可以给构造函数**加上判断**，**限制创建多个实例**，如下：

private Singleton() { 
         if (null != Singleton.singleton) { 
             throw new RuntimeException();
        }
    }

# 五、单例模式中的单例对象会不会被垃圾回收 #

对于JDK1.2后的JVM HotSpot来说，判断对象可以回收需要经过可达性分析，由于单例对象被其类中的静态变量引用，所以JVM认为对象是可达的，不会被回收。  
另外，**对于JVM方法区回收，由堆中存在单例对象，所以单例类也不会被卸载，其静态变量引用也不会失效**。

# 六、多JVM/ClassLoader的系统使用单例类 #

**不同ClassLoader加载同一个类，对类本身的对象（Singleton.class）来说是不一样的，所以可以创建出不同的单例对象**，对不同JVM的情况更是如此，这些在JavaEE开发中还是比较常见。  
所以，在多JVM/ClassLoader的系统使用单例类，需要注意单例对象的状态，最好使用无状态的单例类。

# 七、Spring（IOC框架）实现的单例 #

Spring的一个核心功能控制反转（IOC）或称依赖注入（DI）：  
**高层模块通过接口编程，然后通过配置Spring的XML文件或注解来注入具体的实现类（Bean）。  
这样的好处的很容易扩展，想要更换其他实现类时，只需要修改配置就可以了。通过IOC容器来实现，其默认生成的Bean是单例的（在整个应用中（一般只用一个IOC容器），只创建Bean的一个实例，多次注入同一具体类时都是注入同一个实例）**  
IOC容器来实现过程简述如下：  
**当需要注入Bean时，IOC容器首先解析配置找到具体类，然后判断其作用域（@Scope注解）；  
如果是默认的单例@Scope(ConfigurableBeanFactory.SCOPE\_SINGLETON)，则查找容器中之前有没有为其创建了Bean实例；  
如果有则直接注入该Bean实例，如果没有生成一个放到容器中保存（ConcurrentHashMap – map.put(bean\_id, bean)），再注入。**  
注：**其中解析配置查找具体类、生成Bean实例和注入过程都是通过Java反射机制实现的。**

从上面可以了解到，Spring实现的单例和我们所说的单例设计模式不是一个概念：  
**前者是IOC容器通过Java反射机制实现，后者只是一种编程方法（套路）。  
但总的来说，它们都可以实现“单例”。**

参考如下：  
https://blog.csdn.net/Ricky\_Monarch/article/details/99407326  
https://blog.csdn.net/tjiyu/article/details/76572617  
https://blog.csdn.net/qq\_36523667/article/details/79014324  
https://blog.csdn.net/naerna/article/details/80498633  
https://blog.csdn.net/zcw4237256/article/details/79670608