单例模式
1、懒汉式
1.1 懒汉式,线程不安全
当有多个线程并行调用 getInstance() 的时候,就会创建多个实例。也就是说在多线程下不能正常工作。
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
1.2 懒汉式,线程安全
为了解决上面的问题,最简单的方法是将整个 getInstance() 方法设为同步(synchronized)。虽然做到了线程安全,并且解决了多实例的问题,但是它并不高效。因为在任何时候只能有一个线程调用 getInstance() 方法。但是同步操作只需要在第一次调用时才被需要,即第一次创建单例实例对象时。这就引出了双重检验锁。
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static Singleton getInstance() {
synchronized(){
if (instance == null) {
instance = new Singleton();
}
}
return instance;
}
}
2、饿汉式
public class Singleton{
//类加载时就初始化
private static final Singleton instance = new Singleton();
private Singleton(){}
public static Singleton getInstance(){
return instance;
}
}
3、双重检验锁
双重检验锁模式(double checked locking pattern),是一种使用同步块加锁的方法。会有两次检查 instance == null
,一次是在同步块外,一次是在同步块内。可能会有多个线程一起进入同步块外的 if,如果在同步块内不进行二次检验的话就会生成多个实例了。
class Singleton{
//第二层锁,volatile关键字禁止指令重排
private static volatile Singleton singleton;
private Singleton(){}
public static Singleton getInstance(){
//第一层检查,检查是否有引用指向对象,高并发情况下会有多个线程同时进入
if(singleton==null){
//第一层锁,保证只有一个线程进入
synchronized (Singleton.class){
//双重检查,防止多个线程同时进入第一层检查(因单例模式只允许存在一个对象,故在创建对象之前无引用指向对象,所有线程均可进入第一层检查)
//当某一线程获得锁创建一个Singleton对象时,即已有引用指向对象,singleton不为空,从而保证只会创建一个对象
//假设没有第二层检查,那么第一个线程创建完对象释放锁后,后面进入对象也会创建对象,会产生多个对象
//第二层检查
if(singleton==null){
//volatile关键字作用为禁止指令重排,保证返回Singleton对象一定在创建对象后
singleton=new Singleton();
//singleton=new Singleton语句为非原子性,实际上会执行以下内容:
//(1)在堆上开辟空间;(2)属性初始化;(3)引用指向对象
//假设以上三个内容为三条单独指令,因指令重排可能会导致执行顺序为1->3->2(正常为1->2->3),当单例模式中存在普通变量需要在构造方法中进行初始化操作时,单线程情况下,顺序重排没有影响;但在多线程情况下,假如线程1执行singleton=new Singleton()语句时先1再3,由于系统调度线程2的原因没来得及执行步骤2,但此时已有引用指向对象也就是singleton!=null,故线程2在第一次检查时不满足条件直接返回singleton,此时singleton为null(即str值为null)
//volatile关键字可保证singleton=new Singleton()语句执行顺序为123,因其为非原子性依旧可能存在系统调度问题(即执行步骤时被打断),但能确保的是只要singleton!=0,就表明一定执行了属性初始化操作;而若在步骤3之前被打断,此时singleton依旧为null,其他线程可进入第一层检查向下执行创建对象
}
}
}
return singleton;
}
}
public class ThreadTest{
public static void main(String[] args) {
Singleton singleton=Singleton.getInstance();
System.out.println(singleton);
}
}
4、静态内部类
由于 SingletonHolder 是私有的,除了 getInstance() 之外没有办法访问它,因此它是懒汉式的;同时读取实例的时候不会进行同步,没有性能缺陷;也不依赖 JDK 版本。
public class Singleton {
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton (){}
public static final Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
5、枚举
创建枚举默认就是线程安全的,所以不需要担心double checked locking,而且还能防止反序列化导致重新创建新的对象。
public enum EasySingleton{
INSTANCE;
public void anyMethod(){
}
}
6、IODH
饿汉式单例类不能实现延迟加载,不管将来用不用始终占据内存;懒汉式单例类线程安全控制烦琐,而且性能受影响。可见,无论是饿汉式单例还是懒汉式单例都存在这样那样的问题,有没有一种方法,能够将两种单例的缺点都克服,而将两者的优点合二为一呢?答案是:Yes!下面我们来学习这种更好的被称之为 Initialization Demand Holder (IoDH) 的技术。
在IoDH中,我们在单例类中增加一个静态(static)内部类,在该内部类中创建单例对象,再将该单例对象通过getInstance()方法返回给外部使用,实现代码如下所示:
public class Singleton {
// 私有构造函数,防止外部实例化
private Singleton() { }
// 静态内部类,在这个静态类中初始化单例对象
private static class SingletonHolder {
// 静态变量INSTANCE将在第一次调用getInstance()时进行初始化
private static final Singleton INSTANCE = new Singleton();
}
// 获取单例对象的方法
public static Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
示例:
//Initialization on Demand Holder
class Singleton {
private Singleton() {
}
private static class HolderClass {
private final static Singleton instance = new Singleton();
}
public static Singleton getInstance() {
return HolderClass.instance;
}
public static void main(String args[]) {
Singleton s1, s2;
s1 = Singleton.getInstance();
s2 = Singleton.getInstance();
System.out.println(s1==s2);
}
}
编译并运行上述代码,运行结果为:true,即创建的单例对象s1和s2为同一对象。由于静态单例对象没有作为Singleton的成员变量直接实例化,因此类加载时不会实例化Singleton,第一次调用getInstance()时将加载内部类HolderClass,在该内部类中定义了一个static类型的变量instance,此时会首先初始化这个成员变量,由Java虚拟机来保证其线程安全性,确保该成员变量只能初始化一次。由于getInstance()方法没有任何线程锁定,因此其性能不会造成任何影响。
通过使用IoDH,我们既可以实现延迟加载,又可以保证线程安全,不影响系统性能,不失为一种最好的Java语言单例模式实现方式(其缺点是与编程语言本身的特性相关,很多面向对象语言不支持IoDH)。
项目中的实际使用:
使用IODH单例模式创建线程池
//采用单例模式的IoDH封装线程池的工具类
public class ThreadPoolUtil {
//线程池对象
public ThreadPoolExecutor poolExecutor;
//构造函数私有化
private ThreadPoolUtil(){
//完成线程池对象的实例化
poolExecutor=new ThreadPoolExecutor(4,10,3, TimeUnit.SECONDS,
new ArrayBlockingQueue<>(20), Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
}
//静态内部类 完成对象的实例化
private static class PoolInner{
private final static ThreadPoolUtil pool=new ThreadPoolUtil();
}
//获取唯一实例
public static ThreadPoolUtil getInstance(){
return PoolInner.pool;
}
}