java单例模式

客官°小女子只卖身不卖艺 2022-04-17 04:05 268阅读 0赞

## 一、什么是单例模式 ##

单例模式简单的说就是应用在整个生命周期内只能有一个实例，也就是只有一个对象。单例模式是一种常用的设计模式，它的好处是可以避免频繁的创建和销毁对象，节约内存，提高性能，降低GC的工作压力。

## 二、单例应该注意的问题 ##

线程安全问题，效率问题。

这里主要围绕线程安全问题和效率改进，介绍单例的几种实现模式

## 三、单例的实现方式 ##

**1.饿汉式单例**  
饿汉式单例就是立即加载，在程序启动或者单例模式类被加载的时候，单例模式类的实例就已经被创建出来了。如果系统中经常要用到该实例，则可以采取饿汉式单例。这种实现方式的缺点很明显，就是比较耗费资源。

public class SingleHungry {
        //私有构造函数，进制通过new创建实例
        private SingleHungry(){}
        
        private static SingleHungry singleHungry = new SingleHungry();
        //对外提供一个获取实例的方法
        public static SingleHungry getInstance() {
            return singleHungry;
        }
    }

**2.懒汉式单例**  
懒汉式单例其实就是延迟加载，不会马上创建类的实例，用到的时候再创建。优点就是节约内存不会浪费资源，但是缺点是多线程的情况下，存在线程不安全的问题。  
例如：当两个线程同时运行到判断singleLazy是否为空的if语句，并且singleLazy实例确实没有创建好时，那么两个线程都会创建一个实例。  
这种实现方法推荐99%的情况都不要使用

public class SingleLazy {
    
        private SingleLazy(){}
    
        private static SingleLazy singleLazy = null;
    	//线程不安全，会创建多个实例
        public static SingleLazy getInstance() {
            if (singleLazy == null) {
                singleLazy = new SingleLazy();
            }
            return singleLazy;
        }
    }

既然不安全，会产生多个实例，那么如何使线程安全呢？可以加同步锁，关键字synchronized。  
这种实现方法同样推荐99%的情况都不要使用

public class SingleLazy {
    
        private SingleLazy(){}
    
        private static SingleLazy singleLazy = null;
    
        public static synchronized SingleLazy getInstance() {
            if (singleLazy == null) {
                singleLazy = new SingleLazy();
            }
            return singleLazy;
        }
    }

这时候便解决了线程不安全的问题，但是新的问题来了，方法上加了同步锁显然会大大降低效率，下一个线程必须等上一个线程执行完成释放之后，才能获取对象进行操作，效率太低了。

这时候进行进一步的优化，不对方法进行加锁，而是只对产生对象的对代码块进行加锁处理。这时候就要用到双重校验机制了，也就是DCL双重检查锁机制。

public class SingleLazy {
    
        private SingleLazy(){}
    
        private static SingleLazy singleLazy = null;
    
        public static SingleLazy getInstance() {
            if (singleLazy == null) {
                synchronized (SingleLazy.class) {
                    if (singleLazy == null) {
                      singleLazy = new SingleLazy();
                    } 
                } 
            }
            return singleLazy;
        }
    }

到这里，DCL双重检查锁机制很好的解决了懒汉式单例的效率问题和线程安全问题，其实这也是常用的一种方法。

**3.静态内部类实现单例**  
除了上面的方法之外，我们也可以用静态内部类的方法实现单例。

public class Single {
        
        private Single(){}
    
        private static class GetInstance {
            private static Single single = new Single();
        }
    
        public static Single getInstance() {
            return GetInstance.single;
        }
    
    }

这种办法的原理在于JVM的特性：类的静态成员只会被加载一次，进而保证只有一个实例。静态内部类实现单例的优点是资源利用率高。

**4.静态代码块实现单例**

public class Single {
    
        private Single(){}
        
        private static Single single = null;
    
        static {
            single = new Single();
        }
    
        public static Single getInstance() {
            return single;
        }
    
    }

这种方法实际和第一种很类似，也是饿汉式单例。

**5.枚举法实现单例**

public enum EnumSingle {
    
        Instance;
    
        public void funs() {
            //doSomething
        }
    
    }

可以看出，枚举实现单例极其简单，具体调用只需EnumSingle.Instance就可以创建实例。  
同时，由于创建枚举实例的过程是线程安全的，所以这种写法也没有多线程安全的问题。  
借用 《Effective Java》一书中的话 -> **单元素的枚举类型已经成为实现Singleton的最佳方法。**