有些对象我们只需要一个，比如，配置文件、工具类、线程池、缓存、日志对象等。如何保证对象/实例只有一个？我们可以通过单例模式实现。
Java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。
单例模式有以下特点：
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。
单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。
一、饿汉式
public class Singleton {
private Singleton(){}
//在类初始化时，已经自行实例化
private static final Singleton singleton = new Singleton();
/**
* 静态工厂方法
*/
public static Singleton getInstance(){
return singleton;
}
}
饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。
二、懒汉式
public class Singleton {
private Singleton(){}
private static Singleton singleton = null;
/**
* 静态工厂方法,在第一次调用的时候加载
*/
public static Singleton getInstance(){
if(singleton==null){
singleton = new Singleton();
}
return singleton;
}
}
Singleton通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问。
（事实上，通过Java反射机制是能够实例化构造方法为private的类的，那基本上会使所有的Java单例实现失效。此问题在此处不做讨论，姑且掩耳盗铃地认为反射机制不存在。）
但是以上懒汉式单例的实现没有考虑线程安全问题，它是线程不安全的，并发环境下很可能出现多个Singleton实例，要实现线程安全，有以下三种方式，都是对getInstance这个方法改造，保证了懒汉式单例的线程安全。
第一种：在getInstance方法上加同步
public class Singleton {
private Singleton(){}
private static Singleton instance = null;
public static synchronized Singleton getInstance(){
if(instance==null){
instance = new Singleton();
}
return instance;
}
}
第二种：双重检查锁定
public class Singleton {
private Singleton(){}
private static Singleton instance = null;
public static Singleton getInstance(){
if(instance==null){
synchronized(Singleton.class){
instance = new Singleton();
}
}
return instance;
}
}
第三种：静态内部类
public class Singleton {
private Singleton(){}
private static Singleton instance = null;
public static Singleton getInstance(){
if(instance==null){
synchronized(Singleton.class){
instance = new Singleton();
}
}
return instance;
}
}
这种比上面1、2都好一些，既实现了线程安全，又避免了同步带来的性能影响。
三、登记式
/**
* 类似Spring里面的方法，将类名注册，下次从里面直接获取
*/
public class Singleton {
private static Map<String, Singleton> map = new HashMap<String, Singleton>();
static {
Singleton instance = new Singleton();
map.put(instance.getClass().getName(), instance);
}
private Singleton(){}
/**
* 静态工厂方法,返还此类惟一的实例
*/
public static Singleton getInstance(String name){
if(name == null){
name = Singleton.class.getName();
}
if(map.get(name)==null){
try{
map.put(name, (Singleton)Class.forName(name).newInstance());
}catch(Exception e){
e.printStackTrace();
}
}
return map.get(name);
}
}
登记式单例实际上维护了一组单例类的实例，将这些实例存放在一个Map（登记薄）中，对于已经登记过的实例，则从Map直接返回，对于没有登记的，则先登记，然后返回。
四、区别
从名字上来说，饿汉和懒汉，饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了，而懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例。
另外从以下两点再区分以下这两种方式：
1、线程安全：
饿汉式天生就是线程安全的，可以直接用于多线程而不会出现问题，
懒汉式本身是非线程安全的，为了实现线程安全有几种写法，分别是上面的1、2、3，这三种实现在资源加载和性能方面有些区别。
2、资源加载和性能：
饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成；
而懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要做初始化，如果要做的工作比较多，性能上会有些延迟，之后就和饿汉式一样了。
至于1、2、3这三种实现又有些区别，
第1种，在方法调用上加了同步，虽然线程安全了，但是每次都要同步，会影响性能，毕竟99%的情况下是不需要同步的，
第2种，在getInstance中做了两次null检查，确保了只有第一次调用单例的时候才会做同步，这样也是线程安全的，同时避免了每次都同步的性能损耗
第3种，利用了classloader的机制来保证初始化instance时只有一个线程，所以也是线程安全的，同时没有性能损耗，所以一般我倾向于使用这一种。
以上为转载...
五、实际应用中的一个例子
缓存工具，采用登记式
/**
* 通过把数据库中的数据全部加载到 map 中来实现的数据缓存.
*/
public class CacheManager {
private Map<String, CacheBase> bucket = new ConcurrentHashMap<String, CacheBase>();
public <T extends CacheBase> T getCache(Class<T> cls) {
CacheBase cache = bucket.get(cls.getSimpleName());
if (cache == null) {
synchronized (this) {
// 获得缓存对象
cache = SpringContext.getContext().getBean(cls);
// 缓存初始化
boolean b = cache.init();
if (!b) {
throw new RuntimeException("init error!");
}
bucket.put(cls.getSimpleName(), cache);
}
}
return (T) cache;
}
/**
* 预先调用一下，让缓存初始化
*/
public void prepare(Class... cls) {
for (Class class1 : cls) {
this.getCache(class1);
}
}
/**
* 清除缓存
*/
public <T extends CacheBase> void destoryCache(Class<T> cls) {
CacheBase cache = bucket.get(cls.getSimpleName());
if (cache == null) {
return;
}
synchronized (cache) {
cache.destroy();
bucket.remove(cls.getSimpleName());
}
}
}
缓存类-父类
public abstract class CacheBase {
protected abstract boolean init();
protected abstract void destroy();
}
缓存类-子类
public class ChildrenCache extends CacheBase {
private Map<Long, ObjectCache> resultMap = new HashMap<Long, ObjectCache>();
public ObjectCache getObjectCache(long id) {
return resultMap.get(id);
}
protected boolean init() {
List<ObjectCache> eventList = new ArrayList<ObjectCache>();
/**
* 这里一般是业务逻辑，从数据库取需要缓存的数据
*/
if (eventList == null || eventList.isEmpty()) {
return false;
}
for (ObjectCache mr : eventList) {
long id = mr.getId();
if (resultMap.get(id) == null) {
resultMap.put(id, mr);
}
}
return true;
}
protected void destroy() {
resultMap.clear();
}
}
运用加载缓存
private void readyCache() {
CacheManager cacheManager = applicationContext.getDao(CacheManager.class);
cacheManager.prepare(ChildrenCache.class);
}