设计模式第四弹，单例模式

单例模式：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。
三个要点：一是某个类只能有一个实例，二是它必须能自行创建这个实例，三十它必须自行向整个系统提供这个实例。
Singleton:在单例类的内部实现只生成一个实例，同时它提供一个静态的getInstance()工厂方法，让客户可以方位它的唯一实例，为了防止在外部实例化，将其构造函数私有化，在单例类内部定义一个Singleton类型的静态对象，作为外部共享的唯一实例。
常见的种方式：

//饿汉式
class EagerSingleton {
    private static EagerSingleton instance = new EagerSingleton();
    private EagerSingleton() {
    }
    public static EagerSingleton getInstance() {
        return instance;
    }
}
//懒汉式方法锁
class LazySignleton {
    private static LazySignleton instance = null;
    private LazySignleton() {
    }
    synchronized public static LazySignleton getInstance() {
        if (instance == null) {
            instance = new LazySignleton();
        }
        return instance;
    }
}
//懒汉式代码块锁
class LazySignletonBetter {
    private static LazySignletonBetter instance = null;
    private LazySignletonBetter() {
    }
    public static LazySignletonBetter getInstance() {
        if (instance == null) {
            synchronized (LazySignletonBetter.class) {
                instance = new LazySignletonBetter();
            }
        }
        return instance;
    }
}
//懒汉式代码块锁双重校验
class LazySignletonBest {
    private static LazySignletonBest instance = null;
    private LazySignletonBest() {
    }
    public static LazySignletonBest getInstance() {
        if (instance == null) {
            synchronized (LazySignletonBest.class) {
                if (instance == null) {
                    instance = new LazySignletonBest();
                }
            }
        }
        return instance;
    }
}
//静态内部类
class Signleton {
    private Signleton() {
    }
    private static class HolderClass {
        private final static Signleton instance = new Signleton();
    }
    public static Signleton getInstance() {
        return HolderClass.instance;
    }
}

饿汉式单例类在类被加载时就将自己实例化，它的优点在于无须考虑多线程访问问题，可以确保实例的唯一性；从调用速度和反应时间角度来讲，由于单例对象一开始就得以创建，因此要优于懒汉式单例。但是无论系统在运行时是否需要使用该单例对象，由于在类加载时该对象就需要创建，因此从资源利用效率角度来讲，饿汉式单例不及懒汉式单例，而且在系统加载时由于需要创建饿汉式单例对象，加载时间可能会比较长。
懒汉式单例类在第一次使用时创建，无须一直占用系统资源，实现了延迟加载，但是必须处理好多个线程同时访问的问题，特别是当单例类作为资源控制器，在实例化时必然涉及资源初始化，而资源初始化很有可能耗费大量时间，这意味着出现多线程同时首次引用此类的机率变得较大，需要通过双重检查锁定等机制进行控制，这将导致系统性能受到一定影响。
静态内部类:我们既可以实现延迟加载，又可以保证线程安全，不影响系统性能，不失为一种最好的Java语言单例模式实现方式。
饿汉式的第三种：
考虑到“原子操作”，“指令重排”，目前的双重检查还不知最安全的。
知识点：“原子操作”
简单来说，原子操作（atomic）就是不可分割的操作，在计算机中，就是指不会因为线程调度被打断的操作。
知识点：什么是指令重排？
简单来说，就是计算机为了提高执行效率，会做的一些优化，在不影响最终结果的情况下，可能会对一些语句的执行顺序进行调整。直接上代码吧

class LazySignletonBest {
    private volatile static LazySignletonBest instance = null;
    private LazySignletonBest() {
    }
    public static LazySignletonBest getInstance() {
        if (instance == null) {
            synchronized (LazySignletonBest.class) {
                if (instance == null) {
                    instance = new LazySignletonBest();
                }
            }
        }
        return instance;
    }
}

volatile关键字的意思：就是不是从线程内存中读取这个变量，二是从主内存中读取，在这里面的应用有两点：

这个变量不会在多个线程中存在复本，直接从内存读取。
这个关键字会禁止指令重排序优化。也就是说，在 volatile 变量的赋值操作后面会有一个内存屏障（生成的汇编代码上），读操作不会被重排序到内存屏障之前。
同样在饿汉式的静态成员上也可以加上volatile关键字
private volatile static EagerSingleton instance = new EagerSingleton();

更好的一种方式是使用枚举。不过用的人很少，而且听说枚举在android上有性能的损耗，没有具体研究过。目前常用的就是静态内部类的方法。

设计模式第四弹，单例模式

"设计模式"

设计模式第四弹，单例模式

FEATURED TAGS

FRIENDS