设计模式--单例模式

什么是单例模式

保证一个类只有一个实例，并且提供一个访问该全局访问点；

单例优缺点

优点：

    1.在单例模式中，活动的单例只有一个实例，对单例类的所有实例化得到的都是相同的一个实例。这样就防止其它对象对自己的实例化，确保所有的对象都访问一个实例

    2.单例模式具有一定的伸缩性，类自己来控制实例化进程，类就在改变实例化进程上有相应的伸缩性。

    3.提供了对唯一实例的受控访问。

    4.由于在系统内存中只存在一个对象，因此可以节约系统资源，当 需要频繁创建和销毁的对象时单例模式无疑可以提高系统的性能。

    5.允许可变数目的实例。

    6.避免对共享资源的多重占用。

缺点：

1.不适用于变化的对象，如果同一类型的对象总是要在不同的用例场景发生变化，单例就会引起数据的错误，不能保存彼此的状态。

    2.由于单利模式中没有抽象层，因此单例类的扩展有很大的困难。

    3.单例类的职责过重，在一定程度上违背了“单一职责原则”。

    4.滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。

单例的创建方式

1.饿汉式：效率高，天生线程安全。即使不使用类加载时也创建，占内存。

测试代码：

private static final Singletion01 singletion01 = new Singletion01();

/**
* 默认构造方法改为私有，防止外部new 实例
*/
private Singletion01(){
System.out.println("初始化构造方法");
}

public static Singletion01 getIntance(){

return singletion01;
}

public static void main(String[] args) {
Singletion01 h1 = Singletion01.getIntance();
Singletion01 h2 = Singletion01.getIntance();
System.out.println(h1.hashCode());
System.out.println(h2.hashCode());
}

2.懒汉式：需要时创建，不占内存。天生线程不安全，需要加synchronized关键字实现线程同步安全。效率低

测试代码：

private static Singletion02 singletion02 = null;

private Singletion02(){
System.out.println("初始化。。。。。");
}


public synchronized static Singletion02 getInstance(){
if(singletion02 == null){
singletion02 = new Singletion02();
}
return singletion02;
}

public static void main(String[] args) {
List<ThreadTest> listTh = new ArrayList<ThreadTest>();
for(int i = 0; i < 10; i++){
listTh.add(new ThreadTest());
}

for(ThreadTest t : listTh){
t.start();
}
}
/**
 * 内部类 测试线程安全
 * @ClassName: ThreadTest 
 * @Description: TODO
 */
static class ThreadTest extends Thread{

@Override
public void run() {
System.out.println("hashCode:" + Singletion02.getInstance().hashCode());
}

}

3.静态内部类实现单例：比较完善，具备懒汉模式和恶汉模式的优点

private Singletion03(){
System.out.println("初始化。。。。。");
}
/**
* 使用静态内部类，调用时才会创建并且能保证线程安全
* @ClassName: singletionClassInstance 
* @Description: TODO
*/
public static class singletionClassInstance{
private static final Singletion03 singletion03 = new Singletion03();
}


public static Singletion03 getInstance(){
return singletionClassInstance.singletion03;
}

public static void main(String[] args) {
Singletion03 singletion01 = Singletion03.getInstance();
Singletion03 singletion02 = Singletion03.getInstance();
System.out.println(singletion01 == singletion02);
}

4.枚举类实现单例。实现简单，枚举类本身就是单例的。由JVM从根本上防止反射，反序列化的漏洞，但是没有延迟加载。

测试代码：

public class Singletion04 {


public static Singletion04 getInstance() {
return SingletonDemo04.INSTANCE.getInstance();
}
//枚举类
private static enum SingletonDemo04 {
INSTANCE;
// 枚举元素为单例
private Singletion04 singletion04;


private SingletonDemo04() {
singletion04 = new Singletion04();
}


public Singletion04 getInstance() {
return singletion04;
}
}
public static void main(String[] args) {
Singletion04 s1 = Singletion04.getInstance();
Singletion04 s2 = Singletion04.getInstance();
System.out.println(s1 == s2);
}

}

5.双重检查锁实现单例

测试代码：

private static boolean flag = false;

private static Singletion05 singletion05;

private Singletion05(){

}

public static Singletion05 getInstance(){
if(singletion05 == null){
synchronized (Singletion05.class) {
if(singletion05 == null){
singletion05 = new Singletion05();
}
}
}
System.out.println(flag);
return singletion05;
}

public static void main(String[] args) {
Singletion05 singletion05 = Singletion05.getInstance();
Singletion05 singletion06 = Singletion05.getInstance();
System.out.println(singletion05 == singletion06);

}

问题:双重检查锁实现单例会引发出指令重排序问题

指令重排序是为了优化指令，提高程序运行效率。指令重排序包括编译器重排序和运行时重排序。

重排序在单线程情况下不会影响程序执行的结果，但是在多线程情况下容易获取到空对象。

解决方法：使用volatile变量禁止指令重排序，volatile还可以保证多线程间变量修改的可见性。

private static boolean flag = false;

private static volatile Singletion05 singletion05;

private Singletion05(){

}

public static Singletion05 getInstance(){
if(singletion05 == null){
synchronized (Singletion05.class) {
if(singletion05 == null){
singletion05 = new Singletion05();
}
}
}
System.out.println(flag);
return singletion05;
}