前段时间买了几本java相关的书,每天晚上回去看一两个小时,感受颇深.因此写几篇随笔,作为读书笔记,加深下个人理解,顺便与大家分享下.因为水平有限,文章中可能难免有不当之处,希望各位多多指出,小弟在此谢过.
    单例模式(singleton)顾名思义，就是只有一个实例。

作为对象的创建模式， 单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。

    在java语言中，单例模式的两大好处：

        1、对于频繁使用的对象，使用单例模式，可以减少创建对象所花费的时间，对于那些重量级对象而言，是非常可观的系统开销。

         2、由于new的操作次数减少，因此可以降低对内存的使用频率，减轻GC压力，缩短GC停顿时间。

单例模式的三个要点:
     一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。
     一、首先我们来实现一个简单的单例。

1)为了确保一个类只有一个实例，所以我们这里要把类的构造方法使用private修饰。(注：使用private修饰构造方法也不能确保该类不会在其他地方被初始化，使用反射可以做到，但是反射式特殊情况，这里不予考虑。 :)  .)

2)类必须有一个static方法可以产生实例。

/*** 简单的单例模式实现* @author shine*/
public class MySingleton {private MySingleton(){    //使用private修饰，避免在其他地方被实例化System.out.println("create MySingleton class");}private static MySingleton singleton=new MySingleton();public static MySingleton getInstance(){//static方法，提供自身实例return singleton;}
}

测试代码

public class MainTest {public static void main(String[] args) {MySingleton mySingleton=MySingleton.getInstance();}
}

控制台输出：create MySingleton class

到现在，我们已经自己实现了一个单例模式，这种单例模式很简单，而且很可靠。

但是假如我们遇到了这种情况：你只想调用该类的一个静态方法，并不想拿到该类的实例，会发生什么情况？

/*** 简单的单例模式实现* * @author shine*/
public class MySingleton {private MySingleton() { // 使用private修饰，避免在其他地方被实例化System.out.println("create MySingleton class");}private static MySingleton instance= new MySingleton();public static MySingleton getInstance() {// static方法，提供自身实例return instance;}public static void doSomeThing() { //模拟单例类扮演其他角色System.out.println("now is" + new Date());}
}

假如我们的MySingleton类在系统中还扮演其他角色，比如说输出当前时间等等。那么在我们调用这些方法的时候，我们的类实例就会被创建出来。因为我们的instance成员变量是被static修饰的，所以在JVM加载我们的单例类的时候，单例对象就会被建立出来。也就是说，在任何使用单例类的的地方都会初始化我们的单例变量，而无论我们是否需要一个实例。

测试如下

public class MainTest {public static void main(String[] args) {MySingleton.doSomeThing(); //我们只需调用方法，不需要实例}
}

控制台输出如下：

create MySingleton class
        now isWed Dec 12 22:32:03 CST 2012

如果我们的单例类比较重量级，那么同样在这里也是一笔多余的性能开销。

二、为了解决这个问题，我们需要实现延迟加载机制.

/*** 单例模式（懒加载机制）* * @author shine* */
public class LazySingleton {private LazySingleton() {System.out.println("create LazySingleton class");}private static LazySingleton instance = null;public synchronized static LazySingleton getInstance() {if (instance == null) {instance = new LazySingleton();}return instance;}public static void doSomeThing() {// 模拟单例类扮演其他角色System.out.println("now is" + new Date());}
}

首先对于我们的静态成员变量（也就是我们的实例）初始值赋予null.确保系统启动该类被加载的时候没有额外的负担。然后在我们的工厂方法getInstatnce()中，首先判断单例是否已经存在，如果存在则直接返回，否则就创建一个新的实例。

这里需要注意的是，getInstatnce()必须是同步的，因为在多线程环境下，当线程1正在新建单例时，完成赋值操作前。线程2可能正好判断instance为null，也去执行创建实例的操作，有可能导致多个实例被创建。所以同步关键字是必须的。

测试如下

public class MainTest {public static void main(String[] args) {System.out.println("test MySingleton doSomeThing");MySingleton.doSomeThing(); //我们只需调用方法，不需要实例System.out.println("test LazySingleton doSomeThing");LazySingleton.doSomeThing();//我们只需调用方法，不需要实例}
}

控制台输出：

test MySingleton doSomeThing
create MySingleton class
now isWed Dec 12 22:49:54 CST 2012
test LazySingleton doSomeThing
now isWed Dec 12 22:49:54 CST 2012

通过这种方式，我们虽然实现了延迟加载的功能，但是和第一种方式比，它引入了同步关键字，所以多线程环境中，它的时间消耗要远远大于第一种单例模式。为了延迟加载反而降低了系统性能，是不是有点得不偿失呢？我们再对其进行改造：

三、无需同步的延迟加载，提高性能

/*** 单例模式，使用内部类实现的延迟加载* @author shine**/
public class StaticSingleton {private StaticSingleton() {System.out.println("create StaticSingleton class");}public static class SingletonHolder {private static StaticSingleton instance = new StaticSingleton();}public static StaticSingleton getInstance() {return SingletonHolder.instance;}
}

在这段代码中，通过内部类实现单例类的延迟加载。当StaticSingleton被加载的时候，它的内部类不会被初始化，只有在调用getInstance()方法的时候，才会加载内部类，从而初始化instance实例。

因为实例的建立是在类加载的时候完成，所以天生对多线程友好。因此，这种方式兼备以上两种方式的优点。

注：本文部分内容来自《java程序性能优化》一书。转载请注明出处。

以后会持续发表相关的读书笔记，请关注。:) 谢谢。