单例模式的几种实现方式

1.饿汉式单例

    package org.mlinge.s01;  
      
    public class MySingleton {  
          
        private static MySingleton instance = new MySingleton();  
          
        private MySingleton(){}  
          
        public static MySingleton getInstance() {  
            return instance;  
        }  
          
    }  

2.懒汉式单例

 package org.mlinge.s02;  
      
    public class MySingleton {  
          
        private static MySingleton instance = null;  
          
        private MySingleton(){}  
          
        public static MySingleton getInstance() {  
            if(instance == null){  
                instance = new MySingleton();  
            }  
            return instance;  
        }  
    }  

3.线程安全的懒汉式单例

（1）、 方法中声明synchronized关键字

public class MySingleton {  
          
        private static MySingleton instance = null;  
          
        private MySingleton(){}  
          
        public synchronized static MySingleton getInstance() {  
            try {   
                if(instance != null){//懒汉式   
                      
                }else{  
                    //创建实例之前可能会有一些准备性的耗时工作   
                    Thread.sleep(300);  
                    instance = new MySingleton();  
                }  
            } catch (InterruptedException e) {   
                e.printStackTrace();  
            }  
            return instance;  
        }  
    }  

（2）、 同步代码块实现

package org.mlinge.s03;  
      
    public class MySingleton {  
          
        private static MySingleton instance = null;  
          
        private MySingleton(){}  
          
        //public synchronized static MySingleton getInstance() {  
        public static MySingleton getInstance() {  
            try {   
                synchronized (MySingleton.class) {  
                    if(instance != null){//懒汉式   
                          
                    }else{  
                        //创建实例之前可能会有一些准备性的耗时工作   
                        Thread.sleep(300);  
                        instance = new MySingleton();  
                    }  
                }  
            } catch (InterruptedException e) {   
                e.printStackTrace();  
            }  
            return instance;  
        }  
    }  

 

4.正确的双重检查锁

public class Singleton {
    private volatile static Singleton uniqueSingleton;

    private Singleton() {
    }

    public Singleton getInstance() {
        if (null == uniqueSingleton) {
            synchronized (Singleton.class) {
                if (null == uniqueSingleton) {
                    uniqueSingleton = new Singleton();
                }
            }
        }
        return uniqueSingleton;
    }
}

// 需要在`uniqueSingleton`前加入关键字`volatile`。使用了volatile关键字后，重排序被禁止，所有的写（write）操作都将发生在读（read）操作之前

5.静态内部类模式(高并发下单例)

public class SingleTon{
  private SingleTon(){}
 
  private static class SingleTonHoler{
     private static SingleTon INSTANCE = new SingleTon();
 }
 
  public static SingleTon getInstance(){
    return SingleTonHoler.INSTANCE;
  }
}

　　静态内部类的优点是：外部类加载时并不需要立即加载内部类，内部类不被加载则不去初始化INSTANCE，故而不占内存。即当SingleTon第一次被加载时，并不需要去加载　　SingleTonHoler，只有当getInstance()方法第一次被调用时，才会去初始化INSTANCE,第一次调用getInstance()方法会导致虚拟机加载SingleTonHoler类，这种方法不仅能确保线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。

类加载时机：JAVA虚拟机在有且仅有的5种场景下会对类进行初始化。

　　1.遇到new、getstatic、setstatic或者invokestatic这4个字节码指令时，对应的java代码场景为：new一个关键字或者一个实例化对象时、读取或设置一个静态字段时(final修饰、已在编译期把结果放入常量池的除外)、调用一个类的静态方法时。
　　2.使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没进行初始化，需要先调用其初始化方法进行初始化。
　　3.当初始化一个类时，如果其父类还未进行初始化，会先触发其父类的初始化。
　　4.当虚拟机启动时，用户需要指定一个要执行的主类(包含main()方法的类)，虚拟机会先初始化这个类。
　　5.当使用JDK 1.7等动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化。
这5种情况被称为是类的主动引用，注意，这里《虚拟机规范》中使用的限定词是"有且仅有"，那么，除此之外的所有引用类都不会对类进行初始化，称为被动引用。静态内部类就属于被动引用的行列。

　　我们再回头看下getInstance()方法，调用的是SingleTonHoler.INSTANCE，取的是SingleTonHoler里的INSTANCE对象，跟上面那个DCL方法不同的是，getInstance()方法并没有多次去new对象，故不管多少个线程去调用getInstance()方法，取的都是同一个INSTANCE对象，而不用去重新创建。当getInstance()方法被调用时，SingleTonHoler才在SingleTon的运行时常量池里，把符号引用替换为直接引用，这时静态对象INSTANCE也真正被创建，然后再被getInstance()方法返回出去，这点同饿汉模式。那么INSTANCE在创建过程中又是如何保证线程安全的呢？在《深入理解JAVA虚拟机》中，有这么一句话:

　　虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的<clinit>()方法，其他线程都需要阻塞等待，直到活动线程执行<clinit>()方法完毕。如果在一个类的<clinit>()方法中有耗时很长的操作，就可能造成多个进程阻塞(需要注意的是，其他线程虽然会被阻塞，但如果执行<clinit>()方法后，其他线程唤醒之后不会再次进入<clinit>()方法。同一个加载器下，一个类型只会初始化一次。)，在实际应用中，这种阻塞往往是很隐蔽的。

　　故而，可以看出INSTANCE在创建过程中是线程安全的，所以说静态内部类形式的单例可保证线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。

 

注: 内容源自互联网整理,侵权请联系删除