设计模式之单例

一、什么是单例模式：

　　所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)。

二、单例模式的实现方式：（7种）

　　1.饿汉式（静态变量）：

//饿汉式(静态变量)
class Singleton {
    
    //1. 构造器私有化, 外部能new
    private Singleton() {
        
    }
    //2.本类内部创建对象实例
    private final static Singleton instance = new Singleton();
    
    //3. 提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance() {
        return instance;
    }
}

　　　　优：写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。 

　　　　缺：在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。

　　　　评价：这种模式可用，但可能会造成内存浪费

　　2.饿汉式（静态代码块）：

class Singleton {
    
    //1. 构造器私有化, 外部能new
    private Singleton() {
        
    }
    //2.本类内部创建对象实例
    private  static Singleton instance;
    
    static { // 在静态代码块中，创建单例对象
        instance = new Singleton();
    }
    
    //3. 提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance() {
        return instance;
    }
}

　　　　与上面类似

　　3.懒汉式（线程不安全）：　

class Singleton {
    private static Singleton instance;
    
    private Singleton() {}
    
    //提供一个静态的公有方法，当使用到该方法时，才去创建 instance
    //即懒汉式
    public static Singleton getInstance() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

　　　　优：起到了Lazy Loading的效果 

　　　　缺：多线程环境下不可使用这种方式

　　　　评价：只能在单线程下使用

　　4.懒汉式（线程安全，同步方法）

// 懒汉式(线程安全，同步方法)
class Singleton {
    private static Singleton instance;
    private Singleton() {}
    
    //提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
    //即懒汉式
    public static synchronized Singleton getInstance() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

　　　　优：解决了线程不安全问题

　　　　缺：效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行 同步

　　　　评价：不推荐使用

　　5.双重检查

class Singleton {
    private static volatile Singleton instance;
    
    private Singleton() {}
    
    //提供一个静态的公有方法，加入双重检查代码，解决线程安全问题, 同时解决懒加载问题
    //同时保证了效率, 推荐使用
    public static synchronized Singleton getInstance() {
        if(instance == null) {
            synchronized (Singleton.class) {
                if(instance == null) {
                    instance = new Singleton();
                }
            }
            
        }
        return instance;
    }
}

　　　　评价：线程安全；延迟加载；效率较高 ，推荐使用

　　6.静态内部类：　　　

// 静态内部类完成， 推荐使用
class Singleton {
    private static volatile Singleton instance;
    
    //构造器私有化
    private Singleton() {}
    
    //写一个静态内部类,该类中有一个静态属性 Singleton
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton(); 
    }
    
    //提供一个静态的公有方法，直接返回SingletonInstance.INSTANCE
    
    public static synchronized Singleton getInstance() {
        
        return SingletonInstance.INSTANCE;
    }
}

　　　　评价：

• 静态内部类方式在外部类被装载时并不会立即实例化，而是在需要实例化 时，才会装载内部类，从而完成内部的 实例化。
• 类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
• 避免了线程不安全，利用静态内部类特点实现延迟加载，效率高，推荐使用

　　7.枚举类

public class SingletonTest08 {
    public static void main(String[] args) {
        Singleton instance = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance == instance2);
        
    }
}

//使用枚举，可以实现单例, 推荐
enum Singleton {
    INSTANCE; //属性
    public void sayOK() {
        System.out.println("ok~");
    }
}

　　　　评价：借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而 且还能防止反序列化重新创建新的对象，推荐使用

　　8.线程池

public class Singleton {
    
    private Singleton() {}
    private static final ThreadLocal<Singleton> tlSingleton = new ThreadLocal<Singleton>() {
        @Override
        protected Singleton initialValue() {
            return new Singleton();
        }
    };
    public static Singleton getInstance() {
        return tlSingleton.get();
    }
    
}  

　　9.CAS

public class Singleton {

    /**利用AtomicReference */
    private static final AtomicReference<Singleton> INSTANCE = new AtomicReference<Singleton>();
    private Singleton(){}
    //用CAS确保线程安全
    public static final Singleton getInstance(){
        for (;;) {
            Singleton current = INSTANCE.get();
            if (null != current) {
                return current;
            }
            current = new Singleton();
            if (INSTANCE.compareAndSet(null, current)) {
                return current;
            }
        }
    }
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1 == singleton2);
    }
}  

三、单例模式的jdk使用：　　

package java.lang;
 
import java.io.*;
import java.util.StringTokenizer;

public class Runtime {//这里使用了饿汉式，因为runtime肯定会用到，不会浪费资源
    private static Runtime currentRuntime = new Runtime();
 
    public static Runtime getRuntime() { 
    return currentRuntime;
    }
 
   /** Don't let anyone else instantiate this class */
    private Runtime() {}

四、一些常见问题：https://blog.csdn.net/qq_40868987/article/details/103266261

　　1.静态类和单例的区别：

单例可以继承和被继承，方法可以被override，而静态方法不可以。

静态方法中产生的对象会在执行后被释放，进而被GC清理，不会一直存在于内存中。

静态类会在第一次运行时初始化，单例模式可以有其他的选择，即可以延迟加载。

静态方法如果反复的初始化和释放，则会占用很多资源，而使用单例模式将其常驻于内存可以更加节约资源。

静态方法有更高的访问效率。

单例模式很容易被测试。

　　2.序列化和反序列化会破坏单例吗？

　　   会，解决方案：

　　（1）https://blog.csdn.net/weixin_34087301/article/details/91400619

　　（2）https://www.cnblogs.com/chiclee/p/9097772.html

　　3.线程池的单例实现：

　　https://www.cnblogs.com/zhuangyan728/p/6706746.html

　　https://mp.weixin.qq.com/s?src=11&timestamp=1586451635&ver=2268&signature=UhZ9OtKUNP-KVVt8s2q8t0MlH4P5Rts5d0hDebj9u0IWlovSgkG0bM8AQ-oLvRFXjkj8CdeTHSLLyedvrK5aMOfYd*U2mzXxINoDzykwmsI-jC1xJ5gNx*SLFWOJz0ys&new=1