前言
曾经有两个人，一个是A，一个是B，他们俩都是这个世界上独立的个体，每个人都是这个世界上独一无二的。这个A呢，在一出生的时候，别人就会把他需要的食物全部给他，然后等到他饿了的时候，就可以直接拿过来吃，但是在他不饿的时候，天天被在身上确是一种负担，人们都管他叫做饿汉。B呢，则是在出生的时候，并没有任何食物给他，但是在他饿的时候，他连伸手都不用，只需要张嘴喊一嗓子，便有人给他送来了食物，就因为他这么懒，所以被叫做懒汉。为什么要讲这个故事呢，接下来你就会明白了。
单例模式
在web开发中，我们经常碰到这样一种情况，我们在整个项目的上下文中，有且只有一个实例，所有线程操纵的都是它，例如说Mybatis中的SqlSessionFactory。如果说只存在一个实例，那么他绝对是不可以new出来，所以他的构造方法一定是私有的。
单例模式从方式上分为懒汉模式，和饿汉模式，这就像是咱们刚刚提到故事里的B和A一样，具体代码如下：
package singleton;
/**
* 这是懒汉模式，但是对于多线程的情况下是不安全的
*
* @author luckyharry
*
*/
public class SingletonLazyNotSafe {
private SingletonLazyNotSafe() {
System.out.println("单例懒汉模式，无锁，实例化--");
}
private static SingletonLazyNotSafe singletonLazyNotSafe;
public static SingletonLazyNotSafe getInstance() {
if (singletonLazyNotSafe == null) {
singletonLazyNotSafe = new SingletonLazyNotSafe();
}
return singletonLazyNotSafe;
}
}
这是懒汉模式，但是我们会发现getInstance（）方法，多个线程可能会共同竞争，将会导致数据的不统一性，那么我们需要给它添加一个锁，关键字synchronized。
package singleton;
/**
* 这是懒汉模式，对于多线程的情况下是安全的 但是因为加了锁，所以效率比较低
*
* @author luckyharry
*
*/
public class SingletonLazySafe {
private SingletonLazySafe() {
System.out.println("懒汉模式 有锁 实例化--");
}
private static SingletonLazySafe singletonLazySafe;
public static synchronized SingletonLazySafe getInstance() {
if (singletonLazySafe == null) {
singletonLazySafe = new SingletonLazySafe();
}
return singletonLazySafe;
}
}
懒汉模式，他是在当需要获得的时候才实例化，就像是刚刚所说的B那个人一样，实现了懒加载。但是加了锁之后，效率比较低下。
package singleton;
public class SingletonHunger {
private static SingletonHunger singletonHunger=new SingletonHunger();
// 构造器为私有的，不可以通过new实力化
private SingletonHunger() {
System.out.println("初始化 Singleton 饿汉方式--");
}
public static SingletonHunger getInstance() {
return singletonHunger;
}
}
饿汉模式我们不再去考虑多线程的问题，但是它却是在类加载的时候便会实例化单例本身，并未实现懒加载。这就像是刚刚说的A一样，在一出生的时候，该实例化的已经被实例化放在那了。
package singleton;
public class SingletonInnerClass {
// 构造器为私有的，不可以通过new实力化
private SingletonInnerClass() {
System.out.println("初始化 Singleton 内部类方式--");
}
private static class SingletonCreate {
private static SingletonInnerClass singleton = new SingletonInnerClass();
}
public static SingletonInnerClass getInstance() {
return SingletonCreate.singleton;
}
}
这种内部类的形式，既解决了锁的问题，又实现了懒加载，是一种懒汉模式的变种。
接下来就是测试类了。
package singleton;
/**
* 懒汉模式以及饿汉模式的本质区别在于
* 单例的类的初始化的位置，如果我们是在类刚开始初始化的时候就初始化了的化，那么是饿汉加载
* 如果我们是在获取实例的那个方法初始化的化（实现了懒加载），那就是懒汉模式。
* @author luckyharry
*
*/
public class MainTest {
public static void main(String[] args) {
//获得单例中的实例
SingletonInnerClass.getInstance();
SingletonLazyNotSafe.getInstance();
SingletonLazySafe.getInstance();
SingletonHunger.getInstance();
}
}
后记
我会一直以这样通俗易懂的自己能想到的例子，讲解设计模式，最大的启发是来源于《大话设计模式》。非常感觉这本书的作者程杰先生。
