设计模式——单例模式

1. 作用：

保证一个类仅有一个实例，并且提供它的全局访问点。

2. 5种常用的写法

---

1. 饿汉式

//最简单的单例模式
public class SingletonFactory {
    private static volatile SingletonFactory instance = null;

    private static class SingleTon {
        private static SingletonFactory instance = new SingletonFactory();
    }

    private SingletonFactory() {

    }

    public static SingletonFactory getInstance() {
        return instance;
    }

}

'优点：没有加锁，执行效率会提高。'
'缺点：类加载时就初始化，浪费内存。'

2. 懒汉式

(1)一般的懒汉式

public class SingletonFactory {
//私有的静态实例，防止被引用，设置为null，可以实现延迟加载
    private static SingletonFactory instance = null;
//私有构造方法，防止被实例化
    private SingletonFactory() {

    }
//懒汉式1:创建实例
    public static SingletonFactory getInstance() {
        if (instance == null) {
            instance = new SingletonFactory();
        }
        return instance;
    }
}

'优点：延迟加载(需要用的时候才去加载) '
'缺点：线程不安全，在多线程的时候很容易出现不同步的情况，比如在数据库对象进行频繁的读写操作。'

(2)增加同步锁：上面的方式线程不安全，可以增加同步锁

//懒汉式2：解决线程安全问题
public static synchronized SingletonFactory getInstance() {
        if (instance == null) {
            instance = new SingletonFactory();
        }
        return instance;
}

更加普遍的写法

//懒汉式2：解决线程安全问题
public static SingletonFactory getInstance() {
        if (instance == null) {
            synchronized (SingletonFactory.class) {
                instance = new SingletonFactory();
            }
        }
        return instance;
}

'优点：解决了线程不安全的问题'
'缺点：每次调用实例都需要判断同步锁，效率降低'

(3)双重检验锁(DoubleCheckLock)
有的人为解决上面效率的问题，使用了一种双重检验的方式

//双重锁定：只在第一次初始化的时候加上同步锁
public static SingletonFactory getInstance() {
        if (instance == null) {
            synchronized (SingletonFactory.class) {
                if (instance == null) {
                    instance = new SingletonFactory();
                }
            }
        }
        return instance;
}

'存在问题：
instance = new SingletonFactory();
在JVM编译的过程中会出现指令重排的优化过程，这就会导致当 instance实际上还没初始化，就可能被分配了内存空间，
也就是说会出现 instance !=null 但是又没初始化的情况，这样就会导致返回的 instance 不完整。'

'优点：在并发量不多，安全性不高的情况下或许能很完美运行单例模式'
'缺点：不同平台编译过程中可能会存在严重安全隐患'

(4)内部类的实现

//内部类实现单例模式，延迟加载，减少内存开销
public class SingletonFactory {
    private SingletonFactory(){
        
    }
    
    private static class SingleTon {
        private static SingletonFactory instance = new SingletonFactory();
    }

    public SingletonFactory getInstance() {
        return SingleTon.instance;
    }

}

'优点：延迟加载，线程安全（java中class加载时互斥的），也减少了内存消耗'

(5)枚举的方法

public enum SingletonFactory {
     /** 
     * 1.从Java1.5开始支持; 
     * 2.无偿提供序列化机制; 
     * 3.绝对防止多次实例化，即使在面对复杂的序列化或者反射攻击的时候; 
     */ 
    instance;
    
    SingletonFactory(){
        
    }
}

注意：
1. 枚举使用关键字：enum
2. 调用方式：SingletonFactory.instance.方法名

---

以上列举了5种单例的实现方法，下面简单的介绍一下用到的关键字：

1. volatile（非阻塞性的）

• volatile的特性：当我们声明共享变量为volatile后，对这个变量的读/写将会很特别。
• 理解volatile特性的一个好方法是：把对volatile变量的单个读/写，看成是使用同一个监视器锁对这些单个读/写操作做了同步。
• 它的工作原理是：对写和读都是直接操作工作主存的。

2. synchronized 关键字

• synchronized关键字是用来控制线程同步的，就是在多线程的环境下，控制synchronized代码段不被多个线程同时执行，是一种阻塞性的锁,synchronized既可以加在一段代码上，也可以加在方法上。
• synchronized(this)及非static的synchronized方法，只能防止多个线程同时执行同一个对象的同步代码段。当synchronized锁住一个对象后，别的线程如果也想拿到这个对象的锁，就必须等待这个线程执行完成释放锁，才能再次给对象加锁，这样才达到线程同步的目的。即使两个不同的代码段，都要锁同一个对象，那么这两个代码段也不能在多线程环境下同时运行。所以我们在用synchronized关键字的时候，能缩小代码段的范围就尽量缩小，能在代码段上加同步就不要再整个方法上加同步。这叫减小锁的粒度，使代码更大程度的并发。
• 原因是基于以上的思想，锁的代码段太长了，别的线程是不是要等很久。如果用synchronized加在静态方法上，就相当于用××××.class锁住整个方法内的代码块,此时是锁住该类的Class对象,相当于一个全局锁。
• 使用synchronized修饰的方法或者代码块可以看成是一个原子操作。一个线程执行互斥代码过程如下：

1. 获得同步锁；
2. 清空工作内存；
3. 从主内存拷贝对象副本到工作内存；
4. 执行代码(计算或者输出等)；
5. 刷新主内存数据；
6. 释放同步锁。
   所以，synchronized既保证了多线程的并发有序性，又保证了多线程的内存可见性。