单例模式的几种实现

快来打我* 2021-09-26 15:10 332阅读 0赞

1.**饿汉模式** – 线程安全，调用效率高  
在类被加载时初始化instance，调用私有的构造函数，创建单例类的唯一实例。（不能延时加载）  
（构造函数是私有的，因此该类不能被继承）

/* * 饿汉模式 */
    public class EagerSingleton {
        private static final EagerSingleton instance = new EagerSingleton();
        //私有的构造函数
        private EagerSingleton(){}
        //getInstance()方法
        public static EagerSingleton getInstance(){
            return instance;
        }
    }

**2.懒汉模式**  
类的构造函数是私有的，与饿汉模式不同，instance是在第一次被引用时进行实例化。（延时加载）  
懒汉式有两种实现方式：线程安全和线程不安全的  
a）第一种写法，在第一次被引用时进行实例化

/* * 第一种写法，线程不安全 */
    public class LazySingleton1 {
        private static LazySingleton1 instance = null;
        //私有的构造函数
        private LazySingleton1(){}
        public static LazySingleton1 getInstance(){
            if(instance==null){
                instance = new LazySingleton1();//有可能有多个线程进入此状态，导致创建了多个实例。
            }
            return instance;
        }
    }

b)第二种写法  
加入同步锁（synchronized）

/* * 第二种写法，线程安全 */
    public class LazySingleton2 {
        private static LazySingleton2 instance = null;
        //私有的构造函数
        private LazySingleton2(){}
        /*加入同步锁，迫使每个线程在进入该方法前。要等候别的线程离开该方法，即不会有两个线程同时调用该方法 *缺点：只有第一次执行此方法时才需要同步，如果每次调用都同步，降低性能 */
        public static synchronized LazySingleton2 getInstance(){
            if(instance==null){
                instance = new LazySingleton2();
            }
            return instance;
        }
    }

**3.双重检查加锁** –线程安全  
首先检查实例是否已经创建了，未创建才进行同步

public class DoubleCheckLocking {
        //volatile关键字确保实例化时多个线程能正确处理instance变量
        private volatile static DoubleCheckLocking instance = null;
        //私有构造函数
        private DoubleCheckLocking(){}
        public static DoubleCheckLocking getInstance() {
            if(instance == null){
       //检查该实例是否存在，不存在则进入同步区块
                synchronized (DoubleCheckLocking.class) {
                    if(instance==null){
       //进入同步区块后再检查一次，如果仍然不存在才创建实例
                        instance = new DoubleCheckLocking();
                    }
                }
            }
            return instance;        
        }
    }

**4.静态内部类模式**–线程安全，调用效率高  
调用getInstance（）方法时，才实例化instance

public class InnerclassSingleton {
        //静态内部类
        private static class InnerclassSingletonGetInstance {
            public static final InnerclassSingleton instance = new InnerclassSingleton();
        }
        //私有构造器
        private InnerclassSingleton() {
        }
        //只有调用getInstance()时，才会加载类InnerclassSingletonGetInstance，并实例化instance
        public static  InnerclassSingleton getInstance() {
            return InnerclassSingletonGetInstance.instance;
        }
    }

**5.枚举模式** – 线程安全 调用效率高

enum EnumSingleton {
        INSTANCE;
    }