转载请标明：
http://blog.csdn.net/clover_tjp/article/details/26363351
单例分为懒汉模式和饿汉模式：
饿汉模式：
package com.tjp.test;
public class SingletonClass {
private static final SingletonClass instance = new SingletonClass();
public static SingletonClass getInstance() {
return instance;
}
private SingletonClass() {
}
}本文主要分析懒汉模式相关。
先说下以前面试时让我写单例模式我的写法：
package com.tjp.test;
public class SingletonClass {
private static SingletonClass instance = null;
public static synchronized SingletonClass getInstance() {
if(instance==null)
instance=new SingletonClass();
return instance;
}
private SingletonClass() {
}
}
先看下上面写得代码，这个代码基本没有问题，并且还考虑到了线程的问题，但是如果要我打分的话这段代码顶多60分刚及格。那就先分析一下这段代码，这段代码很简单，而且也能在多线程的情况下保证其正确性，但有个致命缺点就是性能，多个线程同时调用这个函数，那这个的性能就可想而知了，每个线程必须等待一个线程执行完才可以进入，这样性能肯定不能满足需求。
再来看下下面的代码：
package com.tjp.test;
public class SingletonClass {
private static SingletonClass instance = null;
private int testNum;
public static SingletonClass getInstance() {
if(instance==null)
{
synchronized (SingletonClass.class) {
if(instance==null)
{
instance=new SingletonClass();
}
}
}
return instance;
}
private SingletonClass() {
testNum=100;
}
public int getTestNum() {
return testNum;
}
}
这段代码将同步块加到函数里，并且在进入同步块之前有个判断，这样当instance不为空的时候，无论有多少线程调用，效率都会非常高。但是这段代码是有问题的代码。
为了了解这段代码的问题所在，那就先分析下Java创建对象时候的内存情况。
instance=new SingletonClass();
这句话在这看似是一句，其实在内存中可以分为一下几步：
1.在堆中创建一个SingletonClass的类对象。
2.调用SingletonClass()函数，来初始化。
3.将类对象地址传递给对象的引用。
还是没有懂得可看这：
http://coolxing.iteye.com/blog/1464501
这个讲的this逃逸(我感觉和我说的这个问题属于一个问题，嘻嘻)
http://zhangjunhd.blog.51cto.com/113473/17124/
还有这里所讲的创建对象及初始化过程
通过这几个步骤，很容易就可以分析出上面的问题所在。
假如第一个线程进来，此时还未创建对象，instance的值为空，进入同步块，此时执行new对象。而执行顺序是1->3->2。在执行完3后，另一个线程进来，此时instance的值已经不为空了，直接返回，之后这个线程来获取testNum，那么获取的值为0.原因是上一个线程还没有执行初始化，这样获取的值就会错误，程序就会出现一些意想不到的bug。
为了解决上面所说的这些问题，比较完美的单例模式(我自己认为的，其他更好的还没看到。。我见识比较少。。要是有更好的欢迎提出)：
package com.tjp.test;
public class SingletonClass {
private static volatile SingletonClass instance = null;
private int testNum;
public static SingletonClass getInstance() {
if(instance==null)
{
synchronized (SingletonClass.class) {
if(instance==null)
{
instance=new SingletonClass();
}
}
}
return instance;
}
private SingletonClass() {
testNum=100;
}
public int getTestNum() {
return testNum;
}
}不仔细的人肯定认为这段代码和上面那段一样，注意看变量声明那块，这段代码在声明变量的时候加了个关键字volatile。那么现在就来说说这个关键字。
在说这个关键字之前得先说下Java的重排序相关(好吧~~这篇说的知识点有点多。。而且很枯燥。。)。
简单来说，重排序的意思就是你在执行Java代码的时候，程序的运行顺序可能和你所写顺序不同。举个例子：
double pi = 3.14; //A
double r = 1.0; //B
double s=pi * r * r; //C
一般认为，我书写的是A->B->C，那么执行的顺序也应该是A->B->C.可是由于重排序的关系执行顺序可能会发生改变，变为B->A->C。因为C和A，B有数据依赖关系，所以C的结果是不会变的，而A B之间不存在数据依赖，他们的执行顺便有可能会发生重排序。对于这个例子来说，无论怎么变，都不会影响数据结果。那么来看看这个例子：
package com.tjp.test;
public class ReorderExample {
int a=0;
boolean flag=false;
public void write()
{
a=2; //1
flag=true; //2
}
public void read()
{
if(flag) //3
{
int i=a*a; //4
}
}
}
如果有两个线程，一个执行write，一个执行read。问i的值会是多少？
首先可以肯定的是值为4.那大家想想有没有可能值为0呢？
根据前面重排序的理论，a和flag没有数据依赖，那么他们在运行时可能会发生重排序，那么就会变为一个线程运行2->1 ，在这个线程运行2的时候另一个运行 3->4 ，也就是运行顺序是2->3->4->1.
解决方法如下：
package com.tjp.test;
public class ReorderExample {
int a=0;
volatile boolean flag=false;
public void write()
{
a=2; //1
flag=true; //2
}
public void read()
{
if(flag) //3
{
int i=a*a; //4
}
}
}只要在flag申明的时候加个volatile就可解决。
那么现在就先分析这段代码。
根据happens-before原则，
根据程序次序：1 happens-before 2, 3 happens-before 4
根据volatile规则：2 happens-befoe 3
根据传递原则：1 happens-before 4
这样就不会出现上面说的：2->3->4->1这样的结果了。
这次再来分析一下上面所说的单例模式。
给instance加上volatile后，会阻止instance重排序，根据规则（对于volatile的读，总是能看到对volatile的最后写入），这样我们new instance的时候，如果instance未写入，其他线程都会取得instance为空，当instance写入后，由于volatile阻止了重排序，这样写入后初始化也完成了，再次获取初始化的值也就是正确的了，也就不会有上面那种错误了。
按道理文章应该到此结束，单例的相关已经分析完成，但是对于volatile的理解可能还是模棱两可，而且在程序中很容易理解错误。
很多人认为我把一个变量加上volatile后就能保证多线程同步，该变量的操作就变成了原子操作，这个想法绝对不对！！！
首先，volatile不能保证同步，他可以阻止重排序，每次读的值是上次赋的值，比如：
a初始值为0,100个线程去操作。
a=a+1;
问a的值是多少？
答案是1到100都可能。有人会说，不是说volatile读的是上次的值嘛，为什么还会有这种情况。对volatile是读取的是上次的值，可是我们要得分析一下a=a+1的操作。从上层来看这就是一步加法操作，可是电脑不认，我们得从汇编角度来看这段代码，汇编寄存器记号什么的我还给老师了，那就用口述吧。
1，获取a的值，将a放到寄存器中；
2，将a自加一；
3，将结果放回变量地址；
这个三步，假如A线程获得a的值，++后，还未放回去，B线程再来获取a的值时，获取的是以前的值，这时a的值就会发生错误。当写入后下一个线程过来读取的就是新的a的值。如此继续下去，a的值肯定会和所想值不一样。
我想现在应该比以前更了解volatile的作用了。
好吧，稍微总结下：
程序中使用volatile，可以防止重排序，这样可以免去重排序所带来的未知错误。
volatile没办法保证同步问题，要解决同步相关还得加synchronized或者lock。
以上文章是自己的认识，有什么不对请指出，谢谢！
更多关于多线程的知识请参考：
“深入理解java内存模型”和“JSR133”这两本书