1.优缺点
单利模式就是在一个jvm中只能存在一个实例（不考虑反射）这样设计主要有两方面好处：
1.从jvm来说，对于频繁使用的对象，可以减去创建的时间（这对于重量级的对象，是非常客观的开销），由于new 对象的操作减少，对系统内存的使用频率降低，将会减轻GC压力，缩短GC停顿时间（摘自 java程序性能优化 --葛一鸣）。
2.从设计来讲，某些实例一个系统中本应只存在一个（逻辑上），并且只对同一对象操作，能有效的保证一致性（并发时可相应处理）。
同时也存在一些需要注意的问题：
1、由于单利模式中没有抽象层，不利于扩展，所以很多责任都是自己扛，可能会导致单例类的职责过重，在一定程度上违背了“单一职责原则”。
2.如这个实例创建过程很慢而且不一定会用到，可能需要延迟加载。
3、滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。
2.实现方式
实现单例的根本是私有化构造器（在类内部创建对象），然后根据不同的场景设计获取实例的方法，下面是几种常见的实现方式。
1.饿汉式： 这种方式在类加载时就完成了初始化，所以类加载较慢，但获取对象的速度快。 基于类加载机制实现可避免多线程的同步问题，但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到延迟加载的效果。
1 public class Singleton1 {//恶汉式
2 private Singleton1(){}
3 private static Singleton1 singleton = new Singleton1();
4 public static Singleton1 getInstance(){
5 return singleton;
6 }
7 }
2.懒汉式：可实现延迟加载，但是多线程下存在致命问题。
1 public class Singleton2 {//懒汉式
2 private Singleton2(){};
3 private static Singleton2 singleton;
4 public static Singleton2 getInstance(){
5 if(singleton == null){
6 singleton = new Singleton2();
7 }
8 return singleton;
9 }
10 }
3.双重检查模式：改进的懒汉式。为解决线程同步问题，最简单的方法是对getInstance方法整体加关键字synchronized，但是这种实现方式效率会至少低2个数量级。其中一种不错的改进方式是双重检查模式（DCL），这种写法在getSingleton方法中对singleton进行了两次判空，第一次是为了不必要的同步，第二次是在singleton等于null的情况下才创建实例。在这里用到了volatile关键字，在这里使用volatile会或多或少的影响性能，但考虑到程序的正确性，牺牲这点性能还是值得的。DCL优点是资源利用率高，第一次执行getInstance时单例对象才被实例化，效率高。缺点是第一次加载时反应稍慢一些，在高并发环境下也有一定的缺陷（DCL失效），虽然发生的概率很小。
1 public class Singleton3 {//双重检查模式（DCL）
2 private Singleton3(){};
3 private static volatile Singleton3 singleton;
4 public static Singleton3 getInstance(){
5 if(singleton == null){
6 synchronized(Singleton3.class){
7 if(singleton == null){
8 singleton = new Singleton3();
9 }
10 }
11 }
12 return singleton;
13 }
14 }
4.静态内部类：既可以实现延迟加载，又不会有线程问题（推荐）
1 public class Singleton4 {//静态内部类模式（DCL）
2 private Singleton4(){};
3 static class ClassHolder{
4 private static Singleton4 singleton = new Singleton4();
5 }
6 public static Singleton4 getInstance(){
7 return ClassHolder.singleton;
8 }
9 }
5.枚举：这种方式是Effective java作者Josh Bloch提倡的方式，它不仅能避免多线程的同步问题，而且还能防止反序列化重新创建对象的问题。听起来很给力，不过工作中基本见过，有机会试试。
1 public enum Singleton5 {//枚举模式
2 INSTANCE;
3 public void whateverMethod(){
4 //同枚举类使用（它本来就是枚举！），不需要获取实例的方法。
5 }
6 }
6.利用容器保证单例：在不考虑容器本身对并发的处理的情况下，这种方式能有效管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。
1 //利用容器实现单例
2 //最好将你要装载的单例对象构造函数私有化，这样可以避免很多问题
3 // 如果你能保证每次都是从这个类加载器获取对象，构造函数是否私有化毫不相干
4 public class SingletonManager {
5 private static Map<String, Object> objMap = new HashMap<String,Object>();
6 public static void registerService(String key, Object instance) {
7 if (!objMap.containsKey(key) ) {
8 objMap.put(key, instance) ;
9 }
10 }
11 public static Object ObjectGetService(String key) {
12 return objMap.get(key) ;
13 }
14 }
3.破坏单例的情况
1.反射：就当他不存在吧。
2.多个类加载器：例如一些servlet容器对每个servlet使用完全不同的类装载器，这样的话如果有两个servlet访问一个单例类，它们就都会有各自的实例。解决方法就是想办法使用同一个类加载器（废话）。
3.序列化复原：当你序列化复原一个单例对象时候，就会出现多个单例对象。如这样：
1 public class Test {
2 public static void main(String[] args) throws IOException, ClassNotFoundException {
3 Singleton1 singleton = Singleton1.getInstance();
4 //先将单例对象序列化到文件
5 FileOutputStream outputStream = new FileOutputStream("E:Singleton.txt");
6 ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
7 objectOutputStream.writeObject(singleton);
8 objectOutputStream.flush();
9 objectOutputStream.close();
10 //从文件读取对象
11 FileInputStream inputStream = new FileInputStream("E:Singleton.txt");
12 ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
13 Singleton1 newSingleton = (Singleton1) objectInputStream.readObject();
14
15 //test
16 System.out.println(singleton == newSingleton); // false
17 System.out.println(singleton == Singleton1.getInstance());// true
18 }
19
20 }
有效的方法是在单例类中加入readResolve方法（序列化操作提供了一个很特别的钩子（hook）类中具有一个私有的被实例化的方法readresolve(),这个方法可以确保类的开发人员在序列化将会返回怎样的object上具有发言权）。例如：
1 public class Singleton1 implements Serializable{//恶汉式
2 private Singleton1(){}
3 private static Singleton1 singleton = new Singleton1();
4 public static Singleton1 getInstance(){
5 return singleton;
6 }
7 private Object readResolve(){
8 return singleton;
9 }
10 }
在运行上面的测试就会的到两个true。