1.什么事单例模式？
单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。
单例模式有以下特点：
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。
单例模式主要分为：饿汉模式，懒汉模式。
饿汉式和懒汉式区别：
从名字上来说，饿汉和懒汉，饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了，而懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例。
单例模式着重涉及到了一个线程安全性的问题。
什么是线程安全？
如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
或者说：一个类或者程序所提供的接口对于线程来说是原子操作，或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题，那就是线程安全的。
2.单例模式应用场景
1. Windows的Task Manager（任务管理器）就是很典型的单例模式（这个很熟悉吧），想想看，是不是呢，你能打开两个windows task manager吗？ 不信你自己试试看哦~
2. windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。
3. 网站的计数器，一般也是采用单例模式实现，否则难以同步。
4. 应用程序的日志应用，一般都何用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
5. Web应用的配置对象的读取，一般也应用单例模式，这个是由于配置文件是共享的资源。
6. 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，因为何用单例模式来维护，就可以大大降低这种损耗。
7. 多线程的线程池的设计一般也是采用单例模式，这是由于线程池要方便对池中的线程进行控制。
8. 操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统
3.单例应用举例。
主要实现与解释都写在了代码之中。
/**
* @FileName Singleton.java
* @Package com.ali.pattern.singleton
* @Description
* <p>这里稍微对这里涉及到的几个关键字做一下介绍：
* 一个变量声明为volatile，就意味着这个变量是随时会被其他线程修改的，
* 因此不能将它cache在线程memory中。volatile是变量修饰符，
* 而synchronized则作用于一段代码或方法。
* volatile只是在线程内存和“主”内存间同步某个变量的值，
* 而synchronized通过锁定和解锁某个监视器同步所有变量的值。
* 显然synchronized要比volatile消耗更多资源。
* 根据程序上下文环境，Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。
final类不能被继承，没有子类，final类中的方法默认是final的。
final方法不能被子类的方法覆盖，但可以被继承。
final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
final不能用于修饰构造方法。
注意：父类的private成员方法是不能被子类方法覆盖的，
因此private类型的方法默认是final类型的。
static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，
也可以形成静态static代码块，但是Java语言中没有全局变量的概念。
被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，
它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，
Java虚拟机就能根据类名在运行时数据区的方法区内找到他们。
因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。
用public修饰的static成员变量和成员方法本质是全局变量和全局方法，
当声明它类的对象市，不生成static变量的副本，而是类的所有实例共享同一个static变量。 </p>
* @Author ali blog:http://www.cnblogs.com/accipiter
* @Date 2016年1月19日下午1:21:46
* @Version V1.0.1
*/
package com.ali.pattern.singleton;
/**
* @ClassName Singleton
* <p>但是以上懒汉式单例的实现没有考虑线程安全问题，它是线程不安全的</p>
* @Description TODO
* @Date 下午1:21:46
*/
public class Singleton {
//饿汉
private static Singleton sigleton1 = new Singleton();
/**
* @Title getInstanceE
* @Description 饿汉模式，本身就是线程安全的。
* @return
* @Return Singleton
* @Throws
* @user Administrator
* @Date 2016年1月19日
*/
public static Singleton getInstanceE(){
return sigleton1;
}
//懒汉
private static Singleton singleton=null;
private Singleton() {
}
/**
* @Title getInstance
* @Description 线程不安全
* @return
* @Return Singleton
* @Throws
* @user Administrator
* @Date 2016年1月19日
*/
public static Singleton getInstance(){
if(null==singleton){
singleton=new Singleton();
}
return singleton;
}
/**
* @Title getInstanceSafe
* @Description 线程安全，每次都要同步，会影响性能，毕竟99%的情况下是不需要同步的，
* @return
* @Return Singleton
* @Throws
* @user Administrator
* @Date 2016年1月19日
*/
public static synchronized Singleton getInstanceSafe(){
if(null==singleton){
singleton=new Singleton();
}
return singleton;
}
/**
* @Title getInstanceSafeD
* @Description 双重锁定
* 确保了只有第一次调用单例的时候才会做同步，这样也是线程安全的，
* 同时避免了每次都同步的性能损耗
*
* @return
* @Return Singleton
* @Throws
* @user Administrator
* @Date 2016年1月19日
*/
public static Singleton getInstanceSafeD(){
if(null==singleton){
synchronized (Singleton.class) {
if(null==singleton){
singleton=new Singleton();
}
}
}
return singleton;
}
/**
* @ClassName LazyHolder
* @Description 静态内部类，既实现了线程安全，又避免了同步带来的性能影响
* @Date 下午1:44:53
*/
private static class LazyHolder{
private static final Singleton singleton=new Singleton();
}
public static final Singleton getInstanceClass(){
return LazyHolder.singleton;
}
public void operate(int i){
System.out.println(i+"、操作！");
}
/**
* @Title main
* @Description TODO
* @param args
* @Return void
* @Throws
* @user Administrator
* @Date 2016年1月19日
*/
public static void main(String[] args) {
Singleton.getInstance().operate(1);
Singleton.getInstanceSafe().operate(2);
Singleton.getInstanceSafeD().operate(3);
Singleton.getInstanceClass().operate(4);
Singleton.getInstanceE().operate(5);
}
}