单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。总之，选择单例模式就是为了避免不一致状态，避免政出多头。
1、常见的单例模式有两种创建方式：所谓饿懒汉式与饿汉式
（1）懒汉式
懒汉式就是不在系统加载时就创建类的单例，而是在第一次使用实例的时候再创建。
package shejimoshi.danLiMoShi;
/**
* 懒汉实例 第一次使用实例时才创建对象
*/
public class TestSingletonLanHan {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
private static TestSingletonLanHan ts1 = null;
// 该类只能有一个实例
private TestSingletonLanHan() {
} // 私有无参构造方法
// 该类必须自行创建
// 有2种方式
// 这个类必须自动向整个系统提供这个实例对象
//public static TestSingletonLanHan getTest() {
//为了保证线程安全，可以添加synchronized关键字来获取同步，但是每次在执行都会进行同步和判断，效率会降低。
public static synchronized TestSingletonLanHan getTest() {
if (ts1 == null) {
ts1 = new TestSingletonLanHan();
}
return ts1;
}
public void getInfo() {
System.out.println("output message " + name);
}
public static void main(String[] args) {
//s和s1是同一个对象，所以赋值会被覆盖
TestSingletonLanHan s = TestSingletonLanHan.getTest();
s.setName("test 1");
System.out.println(s.getName());
TestSingletonLanHan s1 = TestSingletonLanHan.getTest();
s1.setName("test 2");
System.out.println(s1.getName());
TestSingletonLanHan s2 = new TestSingletonLanHan();
s2.setName("test3");
TestSingletonLanHan s3 = new TestSingletonLanHan();
s3.setName("test4");
s.getInfo(); // output message test 2
s1.getInfo(); // output message test 2
s2.getInfo();
s3.getInfo();
//s == s1是成立的，说明改变的是同一个name。
if (s == s1) {
System.out.println("创建的是同一个实例");
}
}
}
（2）饿汉式
在加载类的时候就会创建类的单例，并保存在类中。
package shejimoshi.danLiMoShi;
/**
* 饿汉式 系统加载时创建对象
* 线程安全
*/
public class TestSingletonEHan {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
private TestSingletonEHan(){
}
private static TestSingletonEHan ts1 = new TestSingletonEHan();
private static TestSingletonEHan instance(){
return ts1;
}
public void getInfo() {
System.out.println("output message " + name);
}
public static void main(String[] args) {
TestSingletonEHan s = TestSingletonEHan.instance();
s.setName("test 1");
System.out.println(s.getName());
TestSingletonEHan s1 = TestSingletonEHan.instance();
s1.setName("test 2");
System.out.println(s1.getName());
s.getInfo(); // output message test 2
s1.getInfo(); // output message test 2
//s == s1是成立的，说明改变的是同一个name。
if (s == s1) {
System.out.println("创建的是同一个实例");
}
}
}
2、双重加锁机制
何为双重加锁机制？
在懒汉式实现单例模式的代码中，有使用synchronized关键字来同步获取实例，保证单例的唯一性，但是上面的代码在每一次执行时都要进行同步和判断，无疑会拖慢速度，使用双重加锁机制正好可以解决这个问题：
package shejimoshi.danlimoshi;
/**
* 双重加锁机制
*/
public class TestSingleTonShuangChongJiaSuo {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
private TestSingleTonShuangChongJiaSuo() {
}
private static volatile TestSingleTonShuangChongJiaSuo dl = null;
public static TestSingleTonShuangChongJiaSuo getInstance() {
if (dl == null) {
synchronized (TestSingleTonShuangChongJiaSuo.class) {
if (dl == null) {
dl = new TestSingleTonShuangChongJiaSuo();
}
}
}
return dl;
}
public static void main(String[] args) {
TestSingletonLanHan s = TestSingletonLanHan.getTest();
s.setName("test 1");
System.out.println(s.getName());
TestSingletonLanHan s1 = TestSingletonLanHan.getTest();
s1.setName("test 2");
System.out.println(s1.getName());
s.getInfo(); // output message test 2
s1.getInfo(); // output message test 2
//s == s1是成立的，说明改变的是同一个name。
if (s == s1) {
System.out.println("创建的是同一个实例");
}
}
}
看了上面的代码，有没有感觉很无语，双重加锁难道不是需要两个synchronized进行加锁的吗？
......
其实不然，这里的双重指的的双重判断，而加锁单指那个synchronized，为什么要进行双重判断，其实很简单，第一重判断，如果单例已经存在，那么就不再需要进行同步操作，而是直接返回这个实例，如果没有创建，才会进入同步块，同步块的目的与之前相同，目的是为了防止有两个调用同时进行时，导致生成多个实例，有了同步块，每次只能有一个线程调用能访问同步块内容，当第一个抢到锁的调用获取了实例之后，这个实例就会被创建，之后的所有调用都不会进入同步块，直接在第一重判断就返回了单例。至于第二个判断，个人感觉有点查遗补漏的意味在内（期待高人高见）。
不论如何，使用了双重加锁机制后，程序的执行速度有了显著提升，不必每次都同步加锁。
其实我最在意的是volatile的使用，volatile关键字的含义是：被其所修饰的变量的值不会被本地线程缓存，所有对该变量的读写都是直接操作共享内存来实现，从而确保多个线程能正确的处理该变量。该关键字可能会屏蔽掉虚拟机中的一些代码优化，所以其运行效率可能不是很高，所以，一般情况下，并不建议使用双重加锁机制，酌情使用才是正理！
3、类级内部类方式
饿汉式会占用较多的空间，因为其在类加载时就会完成实例化，而懒汉式又存在执行速率慢的情况，双重加锁机制呢？又有执行效率差的毛病，有没有一种完美的方式可以规避这些毛病呢？
貌似有的，就是使用类级内部类结合多线程默认同步锁，同时实现延迟加载和线程安全。
package shejimoshi.danLiMoShi;
/**
* 类级内部类方式
* 最安全的单例模式
*/
public class TestSingletonNeiBuLei {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
private TestSingletonNeiBuLei() {
}
public static class DanliHolder {
private static TestSingletonNeiBuLei dl = new TestSingletonNeiBuLei();
}
public static TestSingletonNeiBuLei getInstance() {
return DanliHolder.dl;
}
public void getInfo(){
System.out.println("name : " + name);
}
public static void main(String[] args) {
TestSingletonNeiBuLei s = TestSingletonNeiBuLei.getInstance();
s.setName("test 1");
System.out.println(s.getName());
TestSingletonNeiBuLei s1 = TestSingletonNeiBuLei.getInstance();
s1.setName("test 2");
System.out.println(s1.getName());
s.getInfo(); // output message test 2
s1.getInfo(); // output message test 2
//s == s1是成立的，说明改变的是同一个name。
if (s == s1) {
System.out.println("创建的是同一个实例");
}
}
}
如上代码，所谓类级内部类，就是静态内部类，这种内部类与其外部类之间并没有从属关系，加载外部类的时候，并不会同时加载其静态内部类，只有在发生调用的时候才会进行加载，加载的时候就会创建单例实例并返回，有效实现了懒加载（延迟加载），至于同步问题，我们采用和饿汉式同样的静态初始化器的方式，借助JVM来实现线程安全。
其实使用静态初始化器的方式会在类加载时创建类的实例，但是我们将实例的创建显式放置在静态内部类中，它会导致在外部类加载时不进行实例创建，这样就能实现我们的双重目的：延迟加载和线程安全。
4、使用
在Spring中创建的Bean实例默认都是单例模式存在的。