常见单例模式实现方式

单例模式

单例: 有且仅有一个实例,提供全局访问.

1 饿汉式

• 在单例类被加载时候(立即加载),就实例化一个对象并交给自己的引用.
• 线程安全.

public class Singleton1{
    
    private static Singleton1 instance = new Singleton1();
    
    private Singleton1(){}
    
    public static Singleton1 getInstance(){
        return instance;
    }
}

2 懒汉式

• 在真正使用的时候才会实例化一个对象并交给自己的引用(延迟加载)
• 非线程安全

public class Singleton2{
    
    private static Singleton2 instance = null;
    
    private Singleton2(){}
    
    private static Singleton2 getInstance(){
        
        if(null == instance){
            instance = new Singleton2();
        }
        
        return instance;
    }
}

懒汉式与饿汉式比较:

• 从速度和反应时间角度来讲,饿汉式又称立即加载要好一些;
• 从资源利用效率上说,懒汉式要好一些;

在多线程环境下,由于懒汉式非线程安全,可能会出现多实例.
多个线程同时进入if (singleton2 == null) {…} 语句块的情形发生.当这种这种情形发生后,该单例类就会创建出多个实例.

3 同步延迟加载(synchronized)

• 利用synchronized 实现线程安全

public class Singleton32{
    
    private static Singleton3 instance = null;
    
    private Singleton3(){}
    
    private static synchronized Singleton3 getInstance(){
        
        if(null == instance){
            instance = new Singleton3();
        }
        
        return instance;
    }
}

解决了多线程多实例的风险,但是运行效率会很低,因为同步块的作用域有点大,而且锁的粒度有点粗.

4 同步延迟加载(synchronized代码块)

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

解决了多线程多实例的风险,但是运行效率依然很低,同synchronized方法相比,锁的颗粒度减小,效率基本没有提高.

5 双重加锁

• 保证了单例
• 切实提高了程序运行效率

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

对 Singleton5进行第二次检查,目的是避开过多的同步,因为这里的同步只需在第一次创建实例时才会使用到,一旦创建成功,以后获取实例时就不需要同步获取锁了,提高运行效率.但是需要注意的是:必须使用volatile关键字修饰

6 同步延迟加载(静态内部类)

public class Singleton6{
    
    private Singleton6(){}
    
    private static class SingletonHolder{
        private static Singleton6 singleton = new Singleton6();
    }
    
    public static Singleton6 getInstance(){
        return SingletonHolder.singleton;
    }
}

这种方式效率较高,利用静态内部类实现了延迟加载,一旦SingletonHolder类被加载,就如同饿汉式一样创建实例,实现线程安全.

volatile学习笔记