设计模式(单例模式)

单例模式

单例模式有以下特点:

  • 单例类只能有一个实例
  • 单例类必须自己创建自己的唯一实例
  • 单例类必须给所有其他对象提供这一实例

优点:

  • 只有一个实例,可以减少内存开销
  • 避免对资源的多重占用
  • 设置全局资源访问

单例的几种写法:

/************手写一定要自己动手手写 面试你会发现全是手写一个单例模式开始***********/

  • 懒汉式

public class Singleton{
private static Singleton single=null;
private Singleton(){}
public static Singleton getInstance(){
if (single==null){
single=new Singleton();
}
return single;
}
}

/**
 * <pre>
 *     author : lzy
 *     e-mail : zanyang.lin@newbeeair.com
 *     time   : 2017/07/11
 *     desc   : 单例模式的几种写法
 * </pre>
 */

public class Singleton {
    private static Singleton single=null;
    private  Singleton (){}
    public static Singleton getIntstance(){
        if (single==null){
            single=new Singleton();
        }
        return single;
    }

}

这种写法没有考虑线程安全问题,在并发环境下可能出现多个singleton实例

保证线程安全修改如下

1、解决了线程同步 不过效率较低

public class Singleton {
    private static Singleton single=null;
    private  Singleton (){}
    
    //添加同步锁
    public static synchronized Singleton getIntstance(){
        if (single==null){
            single=new Singleton();
        }
        return single;
    }

}

2、在并发量不高 安全性不高情况下可以很好运行 同时避免了每次都同步的性能损耗

package com.example.singleton;

/**
 * <pre>
 *     author : lzy
 *     e-mail : zanyang.lin@newbeeair.com
 *     time   : 2017/07/11
 *     desc   : 单例模式的几种写法
 * </pre>
 */

public class Singleton {
    private volatile static Singleton single = null;

    private Singleton() {
    }

    //添加同步锁
    public static  Singleton getIntstance() {
        if (single == null) {

            //双重检查锁
            synchronized (Singleton.class) {
                if (single == null) {
                    single = new Singleton();
                }
            }

        }
        return single;
    }



}



volatile

  • 原子操作
    简单来说,原子操作(atomic)就是不可分割的操作,在计算机中,就是指不会因为线程调度被打断的操作。比如,简单的赋值是一个原子操作:m = 6; // 这是个原子操作
      假如m原先的值为0,那么对于这个操作,要么执行成功m变成了6,要么是没执行m还是0,而不会出现诸如m=3这种中间态——即使是在并发的线程中。而,声明并赋值就不是一个原子操作:int n = 6; // 这不是一个原子操作对于这个语句,至少有两个操作:①声明一个变量n②给n赋值为6——这样就会有一个中间状态:变量n已经被声明了但是还没有被赋值的状态。——这样,在多线程中,由于线程执行顺序的不确定性,如果两个线程都使用m,就可能会导致不稳定的结果出现。
  • 指令重排
    简单来说,就是计算机为了提高执行效率,会做的一些优化,在不影响最终结果的情况下,可能会对一些语句的执行顺序进行调整。比如,这一段代码:
int a ;   // 语句1 
a = 8 ;   // 语句2
int b = 9 ;     // 语句3
int c = a + b ; // 语句4

正常来说,对于顺序结构,执行的顺序是自上到下,也即1234。但是,由于指令重排
的原因,因为不影响最终的结果,所以,实际执行的顺序可能会变成3124或者1324。由于语句3和4没有原子性的问题,语句3和语句4也可能会拆分成原子操作,再重排。——也就是说,对于非原子性的操作,在不影响最终结果的情况下,其拆分成的原子操作可能会被重新排列执行顺序。
  OK,了解了原子操作和指令重排的概念之后,我们再继续看双重校验锁方式单例模式代码的问题。下面这段话直接从陈皓的文章(深入浅出单实例SINGLETON设计模式)中复制而来:主要在于singleton = new Singleton()这句,这并非是一个原子操作,事实上在 JVM 中这句话大概做了下面 3 件事情:
1). 给 singleton 分配内存
2). 调用 Singleton 的构造函数来初始化成员变量,形成实例
3). 将singleton对象指向分配的内存空间(执行完这步 singleton才是非 null 了)但是在 JVM 的即时编译器中存在指令重排序的优化。
  也就是说上面的第二步和第三步的顺序是不能保证的,最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者,则在 3 执行完毕、2 未执行之前,被线程二抢占了,这时 instance 已经是非 null 了(但却没有初始化),所以线程二会直接返回 instance,然后使用,然后顺理成章地报错。
  再稍微解释一下,就是说,由于有一个『instance已经不为null但是仍没有完成初始化』的中间状态,而这个时候,如果有其他线程刚好运行到第一层if (instance == null)这里,这里读取到的instance已经不为null了,所以就直接把这个中间状态的instance拿去用了,就会产生问题。这里的关键在于——线程T1对instance的写操作没有完成,线程T2就执行了读操作。

volatilel作用 禁止指令重排

volatile关键字的一个作用是禁止指令重排,把instance声明为volatile之后,对它的写操作就会有一个内存屏障(什么是内存屏障?),这样,在它的赋值完成之前,就不用会调用读操作。
  注意:volatile阻止的不singleton = new Singleton()这句话内部[1-2-3]的指令重排,而是保证了在一个写操作([1-2-3])完成之前,不会调用读操作(if (instance == null))。

3、静态内部类 延迟加载,线程安全 减少内存消耗

public class Singleton {
    
    private static class Holder{
        private static final Singleton instance=new Singleton();
    }
    private Singleton(){}
    public static final Singleton getInstance(){
        return Holder.instance;
    }

}
  • 饿汉式

public class Singleton{
private static final Singleton single=new Singleton();
private Singleton(){}
public static Singleton getIntstance(){
return single;

}

}

两者区别:

  • 饿汉式是类一旦加载就把单例初始化完成 保证getinstance的时候 是已经存在的
  • 懒汉只有当调用getInstance的时候才去初始化这个单例
  • 饿汉天生是线程安全的
  • 懒汉本身非线程安全 为了实现线程安全有几种写法

推荐阅读更多精彩内容