百度众说纷纭的情况下就不如自己写例子测试理论，话不多说，上代码：
[java]
public class Sta {
public static long date=System.currentTimeMillis();//1
public int da=1;//3,5
static{
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
单例模式大家并不陌生，也都知道它分为什么懒汉式、饿汉式之类的。但是你对单例模式的理解足够透彻吗？今天我带大家一起来看看我眼中的单例，可能会跟你的认识有所不同。
下面是一个简单的小实例：
[java]
//简单懒汉式
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为空，接下来就会得到两个实例了。这不是我们想要的单例。
接下来我们用加锁的方式来实现互斥，从而保证单例的实现。
[java]
//同步法懒汉式
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()是线程互斥就可以保证线程安全，所以就有了下面这个版本：
[java]
//双重锁定懒汉式
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的实例，因为没有调用构造方法。）&nbs
补充：软件开发 , Java ,
