百度众说纷纭的情况下就不如自己写例子测试理论,话不多说,上代码:

public class Sta {public static long date=System.currentTimeMillis();//1public int da=1;//3,5static{System.out.println("Sta:"+System.currentTimeMillis());//2}public Sta(){System.out.println(System.currentTimeMillis());//4,6}static class st{public static long date=System.currentTimeMillis();//8}public long getDate(){return st.date;//7,9}public static void main(String[] args) {Sta t=new Sta();Sta t1=new Sta();System.out.println(t.getDate());System.out.println(t1.getDate());}
}

通过debug得出加载顺序如上数字:

静态属性-静态代码块-非静态属性-构造方法,这是总体加载顺序,其中静态属性静态代码块在Sta声明的时候开始调用且只加载一次,而静态内部类只有在通过getDate()方法调用时才会加载而且也只加载一次!而这就是下面静态内部类实现线程安全的单例模式的理论基础。

下文转自:http://blog.csdn.net/liushuijinger/article/details/9069801

单例模式大家并不陌生,也都知道它分为什么懒汉式、饿汉式之类的。但是你对单例模式的理解足够透彻吗?今天我带大家一起来看看我眼中的单例,可能会跟你的认识有所不同。

下面是一个简单的小实例:

//简单懒汉式
public class Singleton {  //单例实例变量  private static Singleton instance = null;  //私有化的构造方法,保证外部的类不能通过构造器来实例化  private Singleton() {}  //获取单例对象实例  public static Singleton getInstance() {  if (instance == null) {   instance = new Singleton();   }  System.out.println("我是简单懒汉式单例!");  return instance;  }
} 

很容易看出,上面这段代码在多线程的情况下是不安全的,当两个线程进入if (instance == null)时,两个线程都判断instance为空,接下来就会得到两个实例了。这不是我们想要的单例。

接下来我们用加锁的方式来实现互斥,从而保证单例的实现。

//同步法懒汉式
public class Singleton {  //单例实例变量  private static Singleton instance = null;  //私有化的构造方法,保证外部的类不能通过构造器来实例化  private Singleton() {}  //获取单例对象实例  public static synchronized  Singleton getInstance() {  if (instance == null) {   instance = new Singleton();   }  System.out.println("我是同步法懒汉式单例!");  return instance;  }
}  

加上synchronized后确实保证了线程安全,但是这样就是最好的方法吗?很显然它不是,因为这样一来每次调用getInstance()方法是都会被加锁,而我们只需要在第一次调用getInstance()的时候加锁就可以了。这显然影响了我们程序的性能。我们继续寻找更好的方法。

经过分析发现,只需要保证instance = new Singleton()是线程互斥就可以保证线程安全,所以就有了下面这个版本:

//双重锁定懒汉式
public class Singleton {  //单例实例变量  private static Singleton instance = null;  //私有化的构造方法,保证外部的类不能通过构造器来实例化  private Singleton() {}  //获取单例对象实例  public static Singleton getInstance() {  if (instance == null) {   synchronized (Singleton.class) {  if (instance == null) {   instance = new Singleton();   }  }  }  System.out.println("我是双重锁定懒汉式单例!");  return instance;  }
}

这次看起来既解决了线程安全问题,又不至于每次调用getInstance()都会加锁导致降低性能。看起来是一个完美的解决方案,事实上是这样的吗?

很遗憾,事实并非我们想的那么完美。java平台内存模型中有一个叫“无序写”(out-of-order writes)的机制。正是这个机制导致了双重检查加锁方法的失效。这个问题的关键在上面代码上的第5行:instance = new Singleton(); 这行其实做了两个事情:1、调用构造方法,创建了一个实例。2、把这个实例赋值给instance这个实例变量。可问题就是,这两步jvm是不保证顺序的。也就是说。可能在调用构造方法之前,instance已经被设置为非空了。下面我们一起来分析一下:

假设有两个线程A、B

1、线程A进入getInstance()方法。

2、因为此时instance为空,所以线程A进入synchronized块。

3、线程A执行 instance = new Singleton(); 把实例变量instance设置成了非空。(注意,是在调用构造方法之前。)

4、线程A退出,线程B进入。

5、线程B检查instance是否为空,此时不为空(第三步的时候被线程A设置成了非空)。线程B返回instance的引用。(问题出现了,这时instance的引用并不是Singleton的实例,因为没有调用构造方法。)

6、线程B退出,线程A进入。

7、线程A继续调用构造方法,完成instance的初始化,再返回。

难道就没有一个好方法了吗?好的方法肯定是有的,我们继续探索!

//解决无序写问题懒汉式
public class Singleton {  //单例实例变量  private static Singleton instance = null;  //私有化的构造方法,保证外部的类不能通过构造器来实例化  private Singleton() {}  //获取单例对象实例  public static Singleton getInstance() {  if (instance == null) {   synchronized (Singleton.class) {                  //1  Singleton temp = instance;                //2  if (temp == null) {  synchronized (Singleton.class) {  //3   temp = new Singleton();   //4      }  instance = temp;                  //5        }  }  }  System.out.println("我是解决无序写懒汉式单例!");  return instance;  }
}  

1、线程A进入getInstance()方法。

2、因为instance是空的 ,所以线程A进入位置//1的第一个synchronized块。

3、线程A执行位置//2的代码,把instance赋值给本地变量temp。instance为空,所以temp也为空。

4、因为temp为空,所以线程A进入位置//3的第二个synchronized块。(后来想想这个锁有点多余)

5、线程A执行位置//4的代码,把temp设置成非空,但还没有调用构造方法!(“无序写”问题)

6、如果线程A阻塞,线程B进入getInstance()方法。

7、因为instance为空,所以线程B试图进入第一个synchronized块。但由于线程A已经在里面了。所以无法进入。线程B阻塞。

8、线程A激活,继续执行位置//4的代码。调用构造方法。生成实例。

9、将temp的实例引用赋值给instance。退出两个synchronized块。返回实例。

10、线程B激活,进入第一个synchronized块。

11、线程B执行位置//2的代码,把instance实例赋值给temp本地变量。

12、线程B判断本地变量temp不为空,所以跳过if块。返回instance实例。

到此为止,上面的问题我们是解决了,但是我们突然发现为了解决线程安全问题,但给人的感觉就像身上缠了很多毛线.... 乱糟糟的,所以我们要精简一下:

//饿汉式
public class Singleton {  //单例变量 ,static的,在类加载时进行初始化一次,保证线程安全   private static Singleton instance = new Singleton();      //私有化的构造方法,保证外部的类不能通过构造器来实例化。       private Singleton() {}  //获取单例对象实例       public static Singleton getInstance() {  System.out.println("我是饿汉式单例!");  return instance;  }
}  

看到上面的代码,瞬间觉得这个世界清静了。不过这种方式采用的是饿汉式的方法,就是预先声明Singleton对象,这样带来的一个缺点就是:如果构造的单例很大,构造完又迟迟不使用,会导致资源浪费。

到底有没有完美的方法呢?继续看:

//内部类实现懒汉式
public class Singleton {  private static class SingletonHolder{  //单例变量    private static Singleton instance = new Singleton();  }  //私有化的构造方法,保证外部的类不能通过构造器来实例化。  private Singleton() {  }  //获取单例对象实例  public static Singleton getInstance() {  System.out.println("我是内部类单例!");  return SingletonHolder.instance;  }
}  

懒汉式(避免上面的资源浪费)、线程安全、代码简单。因为java机制规定,内部类SingletonHolder只有在getInstance()方法第一次调用的时候才会被加载(实现了lazy),而且其加载过程是线程安全的(实现线程安全)。内部类加载的时候实例化一次instance。

简单说一下上面提到的无序写,这是jvm的特性,比如声明两个变量,String a; String b; jvm可能先加载a也可能先加载b。同理,instance = new Singleton();可能在调用Singleton的构造函数之前就把instance置成了非空。这是很多人会有疑问,说还没有实例化出Singleton的一个对象,那么instance怎么就变成非空了呢?它的值现在是什么呢?想了解这个问题就要明白instance = new Singleton();这句话是怎么执行的,下面用一段伪代码向大家解释一下:

mem = allocate();             //为Singleton对象分配内存。
instance = mem;               //注意现在instance是非空的,但是还没有被初始化。  ctorSingleton(instance);    //调用Singleton的构造函数,传递instance. 

由此可见当一个线程执行到instance = mem; 时instance已为非空,如果此时另一个线程进入程序判断instance为非空,那么直接就跳转到return instance;而此时Singleton的构造方法还未调用instance,现在的值为allocate();返回的内存对象。所以第二个线程得到的不是Singleton的一个对象,而是一个内存对象。

以上就是就是我对单例模式的一点小小的思考跟理解,热烈欢迎各位大神前来指导批评。

静态内部类、静态变量的加载次数-理解静态内部类实现线程安全的单例模式相关推荐

  1. 静态内部类、静态变量的加载次数-理解静态内部类实现线程安全的单例模式懒加载

    原贴:https://www.cnblogs.com/suncoolcat/p/3362230.html 写的很详细,需细细品味. 百度众说纷纭的情况下就不如自己写例子测试理论,话不多说,上代码: p ...

  2. hql懒加载后判断对象是否存在_hibernate延迟加载(懒加载)详解

    延迟加载 一.什么是懒加载?他的作用? 延迟加载,也叫懒加载,它是Hibernate为提高程序执行效率而提供的一种机制,即只有真正使用该对象的数据时才会创建. Hibernate中主要是通过代理(pr ...

  3. vue 图片拖动加载 类似于地图_前端性能优化之图片懒加载(附vue自定义指令)...

    作者:lzg9527 链接:https://juejin.cn/post/6903774214780616718 在类电商类项目,往往存在大量的图片,如 banner 广告图,菜单导航图,美团等商家列 ...

  4. bootstrap 数据加载中提示_解决Quartz定时器中查询懒加载数据no session的问题

    作者:下一秒升华 出自:CSDN 原文:blog.csdn.net/u013815546/article/details/53032445 相信大家在web开发过程中一定遇到过一种情况,Class班级 ...

  5. java懒加载注解_在springboot中实现个别bean懒加载的操作

    懒加载---就是我们在spring容器启动的是先不把所有的bean都加载到spring的容器中去,而是在当需要用的时候,才把这个对象实例化到容器中. @Lazy 在需要懒加载的bean上加上@Lazy ...

  6. 记录分页懒加载功能,数据列表,每次触底实现分页懒加载

    1. 引用uview加载更多标签 页面中定义 <u-loadmore :status="status" /> data中定义 status:'nomore' 没有更多状 ...

  7. 前端性能优化总结/懒加载、函数节流、优化dom操作、雪碧图、合并文件

    1.减少 HTTP 请求数量 在浏览器与服务器进行通信时,主要是通过 HTTP 进行通信.浏览器与服务器需要经过三次握手,每次握手需要花费大量时间.而且不同浏览器对资源文件并发请求数量有限(不同浏览器 ...

  8. JAVA 静态变量,静态方法,main方法详解(韩顺平)

    目录 一.类变量 1.类变量的引入 2.类变量的定义 3.类变量的特点 4.如何定义类变量 5.如何访问类变量 6.类变量使用细节 二.类方法 1.基本介绍 2.定义类方法 3.类方法的访问 4.类方 ...

  9. swift_043(Swift 懒加载(lazy) )

    懒加载的优点 懒加载(lazy load),其实是延时加载,它的优点显而易见,首先,懒加载将对象的创建延迟到了需要对象的时候,这样减少了内存开销:其次,懒加载将创建对象.相关属性设置内聚在一个&quo ...

最新文章

  1. 如何精确测量一段代码的执行时间
  2. JButton的setRollover出现的奇怪问题
  3. Cloud Studio全文搜索功能介绍
  4. 机器学习两种距离——欧式距离和马氏距离
  5. 可调整大小的div_气液增压缸运行速度的调整以及压力的调节方式
  6. 个推Node.js 微服务实践:基于容器的一站式命令行工具链
  7. 迷你星域冒险服务器维护中,迷你世界星域冒险
  8. NullableT类型
  9. Zabbix Lack of free swap space
  10. micropython入门指南-【micropython入门指南 】读后感 一
  11. mBlock机器人组装教程_mbot机器人如何搭建?mBot机器人套件快速搭建指南
  12. 360无线网卡驱动服务器,360无线网卡驱动
  13. doc88、道客巴巴 文库文档下载
  14. window引导配置bcdedit
  15. 关于微信公众号自动回复文本、图片以及图文
  16. AF BAF tuning <5>
  17. 勘误发布:《数字滤波器的MATLAB与FPGA实现——Xilinx/VHDL版》P320
  18. 企立方:拼多多点击率问题
  19. cite space安装到高分辨率的电脑后界面太小,画面太小怎么办
  20. 备忘录保存为长图的方法

热门文章

  1. 用PHP+MYSQL写一个完整的登录界面
  2. 23web app实现上下左右滑动
  3. java ssm人体健康体检信息管理系统-
  4. 原始资料的收集方法———定性资料的收集
  5. 3dmax:3dmax的软件两大常用工具之基本三维实体(标准基本体、扩展基本体、复合对象)之详细攻略
  6. *oulapp的双向证书破解
  7. 使用VS Code通过Markdown语法快速画流程图时序图等
  8. PySpark与GraphFrames的安装与使用
  9. 服务器-epoll之缓冲区
  10. 视频播放--自动播放