Java多线程(6)
七种单例设计模式的设计
饿汉式
public class Singleton {
// 实例变量
private byte[] data = new byte[1024];
// 定义实例对象的时候直接初始化
private static Singleton instance = new Singleton();
// 私有构造函数
private Singleton() {
}
public static Singleton getInstance() {
return instance;
}
}
饿汉式的关键在于instance作为类变量并且直接得到了初始化，如果主动使用Singleton类，那么instance实例将会直接完成创建
insta作为类变量在类初始化的过程中会被收集劲< clinit >()方法中，该方法能够百分之百保证同步，也就是instance在多线程的情况下不可能被实例化两次
懒汉式
public final class Singleton {
private byte[] data = new byte[1024];
// 定义实例，但是不直接初始化
private static Singleton instance = null;
private Singleton() {
}
public static Singleton getInstance() {
if(null == instance){
instance = new Singleton();
}
return instance;
}
}
懒汉式就是使用类实例的时候再去创建
Singleton.class被初始化的时候instance并不会被实例化，但是getInstance方法放在多线程环境下分析，则会导致instance被实例化不止一次，并不能保证单例的唯一性
懒汉式 + 同步方法
public class Singleton {
private byte[] data = new byte[1024];
private static Singleton instance = null;
private Singleton() {
}
// 加入同步控制，每次只有一个线程能够进入
public synchronized static Singleton getInstance() {
if (null==instance){
instance = new Singleton();
}
return instance;
}
}
考虑到懒汉式无法保证实例的唯一性，此处使用synchronize关键字来修饰getInstance方法，来保证数据的同步性，但是这种方法性能低下。
Double - Check
public class Singleton {
private byte[] data = new byte[1024];
private static Singleton instance = null;
private Singleton() {
}
public static Singleton getInstance() {
// 当instance为null，进入同步代码块，避免了每次都要进入
if (null == instance){
// 只有一个线程能够获得Singleton.class关联的锁
synchronized (Singleton.class){
if (null == instance){
instance = new Singleton();
}
}
}
return instance;
}
}
双重检查机制首次初始化的时候加锁，之后则允许多个线程同时进行getInstance调用获取类的实例
当两个线程发现null == instance时候，只有一个线程有资格进入同步代码块，完成instance的实例化，随后线程发现null == instance不成立时无需进行任何动作
Volatile + Double - Check
上述Double - Check写法看似解决了问题，但是有个很大的隐患。实例化对象的那行代码（instance = new Singleton();），实际上可以分解成以下三个步骤：
-
分配内存空间
-
初始化对象
-
将对象指向刚分配的内存空间
但是有些编译器为了性能的原因，可能会将第二步和第三步进行重排序，顺序就成了：
-
分配内存空间
-
将对象指向刚分配的内存空间
-
初始化对象
这种情况下对应到就是singleton已经不是null，而是指向了堆上的一个对象，但是该对象却还没有完成初始化动作。当后续的线程发现singleton不是null而直接使用的时候，就会出现意料之外的问题
可以使用volatile关键字修饰变量来解决无序写入产生的问题，因为volatile关键字的一个重要作用是禁止指令重排序，即保证不会出现内存分配、返回对象引用、初始化这样的顺序，从而使得双重检测真正发挥作用
public class Singleton {
private byte[] data = new byte[1024];
private volatile static Singleton instance = null;
private Singleton() {
}
public static Singleton getInstance() {
// 当instance为null，进入同步代码块，避免了每次都要进入
if (null == instance){
// 只有一个线程能够获得Singleton.class关联的锁
synchronized (Singleton.class){
if (null == instance){
instance = new Singleton();
}
}
}
return instance;
}
}
Holder方式
public class Singleton {
private byte[] data = new byte[1024];
private Singleton() {
}
// 在静态内部类中持有Singleton实例，并且直接进行初始化
private static class Holder{
private static Singleton instance = new Singleton();
}
public static Singleton getInstance(){
return Holder.instance;
}
}
Holder方式完全借助了类加载的特点
此方式又可以保证数据的同步性，也能保证内存的可见性，指令顺序性，原子性
枚举方式
public enum Singleton {
INSTANCE;
private byte[] data = new byte[1024];
Singleton()
{
System.out.println("INSTANCE will be 初始化");
}
public static void method(){
// 调用该方法会主动使用Singleton，INSTANCE将被实例化
}
public static Singleton getInstance(){
return INSTANCE;
}
}
枚举类型不允许继承，同样是线程安全的且只能被实例化一次
