设计模式之单例设计模式

设计模式之单例设计模式

---

1.初识单例模式：

1.1 什么是单例：

​ 在程序运行，一个类只需要一个实例，不能出现多个实例，就叫单例。

1.2单例的模式动机

​ 在一个系统或平台中，某个类的实例（对象），只需要有一个

1.3单例的实现原理：封装

​ 得到一个类的对象，需要通过new关键字，调用构造方法创建对象

​ 实现过程：

分析：
 	1某个类只能有一个对象，但是构造方法只要一调用就会产生新的对象，可以通过封装将构造方法进行私有化；
 	2若构造方法私有化，那么此类在外部不能创建对象，需要在类内部创建对象
 	3添加一个公开的方法，返回这个对象

1.4需要实现的事项：

​ <1>私有化构造方法

​ <2>在类内创建对象

​ <3>提供一个共有的方法，用来获取本类对象

1.5实现方式：

​ 单例分为懒汉式和饿汉式

核心：
构造方法私有：不能在类外随意创建对象
在类内部声明一个本类静态的对象作为属性
提供一个共有静态的方法用来获取本类对象

1.6代码实现：

/**
 * 懒汉式单例模式
 * instance不使用不会初始化，第一次使用时才初始化。可以延迟对象初始化
 * 优点：节省空间，生命周期短
 * 缺点：有线程安全问题
 */
public class SingleTon {
    //（1）私有化构造方法
    private SingleTon() {
    }
    //（2）类内部创建一个对象
    private static SingleTon instance=null;
    //（3）添加公开的方法，返回这个对象
    public static SingleTon getInstance() {
        if(instance==null) {
            //给对象赋值
            instance=new SingleTon();
        }
        return instance;
    }
}


/**
 * 饿汉式单例模式
 * 优点：不会出现线程安全问题
 * 缺点：会浪费空间，生命周期长
 */
public class SingleTon2 {
    //私有化构造方法
    private SingleTon2() {
    }
    //在单例类中创建对象
    private static final SingleTon2 INSTANCE=new SingleTon2();
    //提供公共的方法，返回这个对象
    public static SingleTon2 getInstance() {
        return INSTANCE;
    }
}

2.多线程中的单例模式（懒汉式单例模式）

​ 代码实现：

public class SingeleTon {
    //（1）私有化构造方法
    private SingeleTon() {

    }
    //（2）类内部创建一个对象
    private static SingeleTon instance=null;
    //（3）添加公开的方法，返回这个对象
    public static SingeleTon getInstance() {
        if(instance==null) {
            //给对象赋值
            instance=new SingeleTon();
        }
        return instance;
    }
}


public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                SingeleTon singeleTon = SingeleTon.getInstance();
                System.out.println(singeleTon.hashCode());
            }
        };

        new Thread(runnable).start();
        new Thread(runnable).start();
        new Thread(runnable).start();

    }

​ 因为单例模式的只会产生一个实例化对象，所以在程序运行后三个线程的哈希值应该是相同的，正常结果应该如下图

​ 但是在运行多次后，会出现哈希值不相同的情况;

​ 为什么会产生这样的原因呢？我们可以做如下分析：

三个哈希值不同，所以说明在创建对象时发生了错误
if(instance==null) {
	instance=new SingeleTon();
}

假设有三个线程：
1.线程1抢到了CPU，在执行完判断语句if(instance==null)后，CPU使用时间结束
2.线程2抢到了CPU，在执行完判断语句if(instance==null)后，CPU使用时间结束
3.线程3抢到了CPU，在执行完判断语句if(instance==null)后，CPU使用时间结束
4.此时三个线程都执行完了判断条件，但都没有进行对象的实例化，所以再次抢到CPU的使用时间时，他们都可以对对象进行实例化，因此产生了错误
        

此时需要在判断条件外加锁，即使用同步代码块：

public class SingeleTon {
    //（1）私有化构造方法
    private SingeleTon() {
    }
    //（2）类内部创建一个对象
    private static SingeleTon instance=null;
    //（3）添加公开的方法，返回这个对象
    public static SingeleTon getInstance() {
        synchronized (SingeleTon.class){
            if(instance==null) {
                //给对象赋值
                instance=new SingeleTon();
            }
        }
        return instance;
    }
}

​ 但是这样的代码还不够完善，如果有大量的线程同时创建一个对象，那么第一个线程执行完判断条件后，返回了对象，其他线程的再次执行开锁判断的代码，都属于无效重复的行为，效率会很低，那我们又该怎么解决这个问题呢？

​ 在同步代码块外层进行判断，形成双重检查，以提高效率，具体实现如下：

public class SingeleTon {
    //（1）私有化构造方法
    private SingeleTon() {
    }
    //（2）类内部创建一个对象
    private static SingeleTon instance=null;
    //（3）添加公开的方法，返回这个对象
    public static SingeleTon getInstance() {
        if(instance == null){
            synchronized (SingeleTon.class){
                if(instance==null) {
                    //给对象赋值
                    instance=new SingeleTon();
                }
            }
        }
        return instance;
    }
}

我们还需要使用volatile（不稳定的）关键字再次优化，原因分析如下：

instance=new SingeleTon();
实例化过程：
1.在堆中开辟空间
2.调用构造方法初始化
3.把地址赋给战中的对象

但JVM在运行过程中可能会对代码进行优化
正常步骤：1->2->3
优化步骤：1->3->2（指令重排序）
该优化过程在单线程中不会产生错误，但是多线程时会导致空指针异常的错误

假如有两个线程需要进行对象实例化，在优化步骤中
线程1抢到CPU 执行了优化后的地址赋值操作后占用时间结束，此时在栈中存在了对象的地址，但是对象属性的初始化操作还没有进行。
线程2抢到CPU 执行代码，此时线程2会进行instance == null的判断，但线程1执行后产生了栈中的地址已经存在，即判断结果是instance ！= null，但这个结果是错误的，该地址并没有指向任何具体的对象属性，即空指针异常


volatile的作用：
（1）保证线程可见性
（2）禁止指令重排序

public class SingeleTon {
    //（1）私有化构造方法
    private SingeleTon() {
    }
    //（2）类内部创建一个对象
    private volatile static SingeleTon instance=null;
    //（3）添加公开的方法，返回这个对象
    public static SingeleTon getInstance() {
        if(instance == null){
            synchronized (SingeleTon.class){
                if(instance==null) {
                    //给对象赋值
                    instance=new SingeleTon();
                }

            }
        }
        return instance;
    }
}

此时代码已经很完善了，但是为了让代码更安全，所以我们需要面对一个问题，如何禁止反射破解：

public class SingeleTon {
    //（1）私有化构造方法
    private SingeleTon() {
    	//禁止反射破解
        synchronized (SingeleTon.class){
            if(instance != null){
                throw new RuntimeException("不能使用反射创建对象");
            }
        }
        
    }
    //（2）类内部创建一个对象
    private volatile static SingeleTon instance=null;
    //（3）添加公开的方法，返回这个对象
    public static SingeleTon getInstance() {
        if(instance == null){
            synchronized (SingeleTon.class){
                if(instance==null) {
                    //给对象赋值
                    instance=new SingeleTon();
                }

            }
        }
        return instance;
    }
}

3.单例模式其他的写法

3.1静态内部类写法：

public class SingleTon {
    private SingleTon(){

    }

    static class Holder{
        private static final SingleTon INSTACNE=new SingleTon();
    }

    public static SingleTon getInstance(){
        return Holder.INSTACNE;
    }

}

​ 优点：

​ (1)节省空间

​ (2)不会有线程安全问题

3.2枚举写法

public enum  SingleTon {
    INSTANCE;
    public static SingleTon getInstance(){
        return INSTANCE;
    }
}

​ 优点：

​ （1）没有线程安全问题

​ （2）禁止了反射破解问题