【题2实现Singleton模式】

【题2实现Singleton模式】
【题目】
设计一个类，我们只能生成该类的一个实例（单例设计模式）

【思路】
不好的解法：
1.只适用于单线程环境
2.虽然再多线程环境中能工作但效率不高
可行的解法：
加同步锁前后2次判断实例是否已存在
强烈推荐解法：
1.利用静态构造函数
2.实现按需创建实例

【单例模式】
单例模式定义：
单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

单例模式特点：
单例类只能有一个实例。
单例类必须自己创建自己的唯一实例。
单例类必须给所有其他对象提供这一实例。

实现
饿汉式

· 属性实例化对象

//饿汉模式：线程安全，耗费资源。
public class HugerSingletonTest {
    //该对象的引用不可修改
    private static final HugerSingletonTest ourInstance = new HugerSingletonTest();
    public static HugerSingletonTest getInstance() {
        return ourInstance;
    }
    private HugerSingletonTest() {
    }
}

· 在静态代码块实例对象

public class Singleton {
    private static Singleton ourInstance;
    static {
         ourInstance = new Singleton();
    }
    public static Singleton getInstance() {
        return ourInstance;
    }
    private Singleton() {
    }
}

分析：饿汉式单例模式只要调用了该类，就会实例化一个对象，但有时我们并只需要调用该类中的一个方法，而不需要实例化一个对象，所以饿汉式是比较消耗资源的。

懒汉式
· 非线程安全

public class Singleton {
    private static Singleton ourInstance;
    public static Singleton getInstance() {
        if (null == ourInstance) {
            ourInstance = new Singleton();
        }
        return ourInstance;
    }
    private Singleton() {
    }
}

分析：如果有两个线程同时调用getInstance()方法，则会创建两个实例化对象。所以是非线程安全的。

· 线程安全：给方法加锁

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

分析：如果有多个线程调用getInstance()方法，当一个线程获取该方法，而其它线程必须等待，消耗资源。

· 线程安全：双重检查锁（同步代码块）

public class Singleton {
    private static Singleton ourInstance;

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

分析：为什么需要双重检查锁呢？因为第一次检查是确保之前是一个空对象，而非空对象就不需要同步了，空对象的线程然后进入同步代码块，如果不加第二次空对象检查，两个线程同时获取同步代码块，一个线程进入同步代码块，另一个线程就会等待，而这两个线程就会创建两个实例化对象，所以需要在线程进入同步代码块后再次进行空对象检查，才能确保只创建一个实例化对象。

·线程安全：静态内部类

public class Singleton {
    private static class SingletonHodler {
        private static Singleton ourInstance = new Singleton();
    }

    public synchronized static Singleton getInstance() {
        return SingletonHodler.ourInstance;
    }
    private Singleton() {
    }
}

分析：利用静态内部类，谋个线程在调用该方法时会创建一个实例化对象。

· 线程安全：枚举

enum SingletonTest {  
    INSTANCE;  
    public void whateverMethod() {
        
    }
}

分析：枚举的方式是《Effective Java》书中提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，但是在枚举中的其他任何方法的线程安全由程序员自己负责。还有防止上面的通过反射机制调用私用构造器。不过，由于Java1.5中才加入enum特性，所以使用的人并不多。

·注：指令重排序
懒汉式的双重检查版本的单例模式，它一定是线程安全的吗？
不一定，因为在JVM的编译过程中会存在指令重排序的问题。
创建一个对象，往往包含三个过程。
对于singleton = new Singleton()，这不是一个原子操作，在 JVM 中包含的三个过程。
1>给 singleton 分配内存
2>调用 Singleton 的构造函数来初始化成员变量，形成实例
3>将singleton对象指向分配的内存空间（执行完这步 singleton才是非 null 了）
但是，由于JVM会进行指令重排序，所以上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是 1-3-2，则在 3 执行完毕、2 未执行之前，被l另一个线程抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以这个线程会直接返回 instance，然后使用，那肯定就会报错了。
针对这种情况，把singleton声明成 volatile ，改进后的懒汉式线程安全（双重检查锁）的代码如下：

public class Singleton {
    //volatile的作用是：保证可见性、禁止指令重排序，但不能保证原子性
    private volatile static Singleton ourInstance;
    public synchronized static Singleton getInstance() {
        if (null == ourInstance) {
            synchronized (Singleton.class) {
                if (null == ourInstance) {
                    ourInstance = new Singleton();
                }
            }
        }
        return ourInstance;
    }
    private Singleton() {
    }
}

·单例模式在JDK8源码中的使用

//饿汉式单例设计模式
public class Runtime {
    private static Runtime currentRuntime = new Runtime();
    public static Runtime getRuntime() {
        return currentRuntime;
    }
    private Runtime() {
    }    
    //省略很多行
}

参考：1.《剑指offer》
2.https://blog.csdn.net/baiye_xing/article/details/76427595

【题2实现Singleton模式】

猜你喜欢