单例模式---初级，饿汉，懒汉，双锁，内部类，方法实现

r囧r小猫 2022-02-24 16:56 192阅读 0赞

**目录**

1.初级写法

2.加锁

3.饿汉式

4.懒汉式

5.双锁检验

6.内部类

--------------------

小二在学习的时候，偶尔看到单例模式的初级写法，便想着将自己目前了解到的单例模式的几种写法做一个小总结。

这里记录一下单例的几种写法和优缺点。

*  1.初级写法
 *  2.加锁
 *  3.饿汉式
 *  4.懒汉式
 *  5.双锁检验
 *  6.内部类

### 1.初级写法 ###

初级模式，便是在类内部声明一个私有的静态变量，并不实例化，实例化在一个静态方法中，通过判断变量是否为空，来觉得是否实例化，不过此种方法在高并发下会出现线程安全问题。

package cn.zzuli.edu.singleton;
    
    /**
     * 最普通的单例模式，此种方式在高并发下会出现线程安全问题
     */
    public class Singleton {
    
        private static Singleton singleton;
    
        private Singleton() {
        }
    
        public static Singleton getInstance(){
            //高并发下出现线程安全问题的地方
            if (singleton == null){
                singleton = new Singleton();
            }
            return singleton;
        }
    }

### 2.加锁 ###

在初级模式中，如果出现了线程安全问题。我们最能想到的便是加锁，使得线程安全问题除去。此种方法又称为懒汉式单例模式。

package cn.zzuli.edu.singleton;
    
    /**
     * 加锁的单例模式，解决了线程安全问题
     */
    public class SSingleton {
    
        private static SSingleton singleton;
    
        private Ssingleton() {
        }
    
        public synchronized static Ssingleton getInstance(){
            if (singleton == null){
                singleton = new Singleton();
            }
            return singleton;
        }
    }

### 3.饿汉式 ###

饿汉式的单例模式的最大特点。是类在加载时就直接初始化了实例。即使没有用到，也会实例化。

package cn.zzuli.edu.singleton;
    
    /**
     * 饿汉式的单例模式
     * 类在加载时就直接初始化了实例。即使没有用到，也会实例化。
     */
    public class EHSingleton {
        //static修饰，在堆内存中只初始化一次，
        private static final EHSingleton EH_SINGLETON = new EHSingleton();
    
        private EHSingleton() {
        }
    //无写操作，只返回堆内存中的唯一一个
        public static EHSingleton getInstance(){
            return EH_SINGLETON;
        }
    }

### 4.懒汉式 ###

懒汉式的单例模式，就是在会发生线程安全的类上加synchronized关键字， 使得方法变为同步方法，解决线程安全问题。

package cn.zzuli.edu.singleton;
    
    /**
     * 懒汉式的单例模式
     * 就是在会发生线程安全的类上加synchronized关键字
     * 使得方法变为同步方法，解决线程安全问题
     */
    public class LHSingleton {
    
        private static LHSingleton lhSingleton;
    
    //构造方法私有化
        private LHSingleton() {
        }
    
        //同步方法，线程安全，但是效率低下
        public static LHSingleton getInstance(){
            if (lhSingleton == null){
                //在会发生线程安全问题的地方加锁
                synchronized(LHSingleton.class){ 
                    lhSingleton = new LHSingleton();
                }
            }
            return lhSingleton;
        }
    }

### 5.双锁检验 ###

双加锁的单例模式  
双重非空判断，new对象前加一次锁。  
volatile关键字，考虑的是，new关键字在虚拟机中执行时其实分为很多步骤，  
具体原因可以参考深入理解java虚拟机一书  
（考虑的是这个new关键字字节码执行时是非原子性的），  
  而volatile关键字可以防止指令重排。

package cn.zzuli.edu.singleton;
    
    /**
     * 双加锁的单例模式
     * 双重非空判断，new对象前加一次锁。
     * volatile关键字，考虑的是，new关键字在虚拟机中执行时其实分为很多步骤，
     * 具体原因可以参考深入理解java虚拟机一书
     * （考虑的是这个new关键字字节码执行时是非原子性的），
     * 而volatile关键字可以防止指令重排。
     */
    public class SynSingleton {
        private volatile static SynSingleton synSingleton;
    
        private SynSingleton() {
        }
    
        public static SynSingleton getInstance(){
            if (synSingleton == null){
                synchronized (SynSingleton.class){
                    if (synSingleton == null) {
                        synSingleton = new SynSingleton();
                    }
                }
            }
            return synSingleton;
        }
    }

### 6.内部类 ###

内部类的单例模式

package cn.zzuli.edu.singleton;
    
    /**
     * 内部类的单例模式
     */
    public class ICSingleton {
        private ICSingleton() {
        }
        public static ICSingleton getInstance(){
            return Singleton.icSingleton;
        }
        //内部类
        private static class Singleton{
            private static ICSingleton icSingleton = new ICSingleton();
        }
    }

小二了解的不多，帮帮我一下。

thx a lot。