找工作，怎么才能拿到高薪offer，对于没有工作过、没有面试过的学员们，当天面试回来一定要总结。面试题一定要记下来，有笔试题就更好了，直接手机拍下来，晚上回来总结；不懂的可以问老师去群里面交流或者是查资料，把整理好的面试题共享，让其他小伙伴看到，每个人都这样做，日积月累我们就会有一个庞大的面试题库，受益你我他。一句话：面试——>总结——>分享。

单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。这样的模式有几个好处：
1、某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。
2、省去了new操作符，降低了系统内存的使用频率，减轻GC压力。
3、有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。（比如一个军队出现了多个司令员同时指挥，肯定会乱成一团），所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程。
首先我们写一个简单的单例类：

public class Singleton {  

    /* 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载 */  

    private static Singleton instance = null;  

    /* 私有构造方法，防止被实例化 */  

    private Singleton() {  

    }  

    /* 静态工程方法，创建实例 */  

    public static Singleton getInstance() {  

        if (instance == null) {  

            instance = new Singleton();  

        }  

        return instance;  

    }  

    /* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */  

    public Object readResolve() {  

        return instance;  

    }  

}  

这个类可以满足基本要求，但是，像这样毫无线程安全保护的类，如果我们把它放入多线程的环境下，肯定就会出现问题了，如何解决？我们首先会想到对getInstance方法加synchronized关键字，如下：

public static synchronized Singleton getInstance() {  
       if (instance == null) {            
               instance = newSingleton();  
       }  
       return instance;  
    }  

但是，synchronized关键字锁住的是这个对象，这样的用法，在性能上会有所下降，因为每次调用getInstance()，都要对对象上锁，事实上，只有在第一次创建对象的时候需要加锁，之后就不需要了，所以，这个地方需要改进。我们改成下面这个：
public static Singleton getInstance() {  
        if (instance == null) {  
            synchronized (instance){  
                if (instance== null) {  
                   instance = new Singleton();  
                }  
            }  
        }  
        return instance;  
    }  

1、最简单的实现
首先，能想到的最简单的实现是，把类的构造函数写成private的，从而保证别的类不能实例化此类。然后在类中返回一个静态示例并返回给调用者。这样，调用者就可以通过这个引用使用这个实例了。
public class Singleton {
        private static final Singleton singleton= new Singleton();

        public static Singleton getInstance() {
                returnsingleton;
        }

        private Singleton() {
        }
}

如上例，外部使用者如果需要使用SingletonClass的实例，只能通过getInstance()方法，并且它的构造方法是private的，这样就保证了只能有一个对象存在。
2、性能优化--lazy loaded
上面的代码虽然简单，但是有一个问题----无论这个类是否被使用，都会创建一个instance对象。如果这个创建很耗时，比如说链接10000次数据库（夸张一点啦....），并且这个类还不一定会被使用，那么这个创建过程就是无用的，怎么办呢？

为了解决这个问题，我们想到的新的解决方案：
public class SingletonClass {
        private static SingletonClass instance =null;

        public static SingletonClassgetInstance() {
                if (instance== null) {
                       instance = new SingletonClass();
                }
                returninstance;
        }

        private SingletonClass() {
        }
}
代码的变化有俩处----首先，把 instance 设置为 null ,知道第一次使用的时候判是否为 null 来创建对象。因为创建对象不在声明处，所以那个 final 的修饰必须去掉。
我们来想象一下这个过程。要使用 SingletonClass ，调用 getInstance（）方法，第一次的时候发现instance时null,然后就创建一个对象，返回出去；第二次再使用的时候，因为这个 instance事static的，共享一个对象变量的，所以instance的值已经不是null了，因此不会再创建对象，直接将其返回。
这个过程就称为lazy loaded ,也就是迟加载-----直到使用的时候才经行加载。

这样写法也比较完美：但是还可以优化
public class SingletonClass {
        private static SingletonClass instance =null;

        public static SingletonClassgetInstance() {
                if (instance== null) {
                       synchronized (SingletonClass.class) {
                               if(instance == null) {
                                      instance = new SingletonClass();
                               }
                       }
                }
                returninstance;
        }

        private SingletonClass() {
        }
}
通过单例模式的学习告诉我们：
1、单例模式理解起来简单，但是具体实现起来还是有一定的难度。
2、synchronized关键字锁定的是对象，在用的时候，一定要在恰当的地方使用（注意需要使用锁的对象和过程，可能有的时候并不是整个对象及整个过程都需要锁）。
到这儿，单例模式基本已经讲完了，结尾处，笔者突然想到另一个问题，就是采用类的静态方法，实现单例模式的效果，也是可行的，此处二者有什么不同？
首先，静态类不能实现接口。（从类的角度说是可以的，但是那样就破坏了静态了。因为接口中不允许有static修饰的方法，所以即使实现了也是非静态的）
其次，单例可以被延迟初始化，静态类一般在第一次加载是初始化。之所以延迟加载，是因为有些类比较庞大，所以延迟加载有助于提升性能。
再次，单例类可以被继承，他的方法可以被覆写。但是静态类内部方法都是static，无法被覆写。

最后一点，单例类比较灵活，毕竟从实现上只是一个普通的Java类，只要满足单例的基本需求，你可以在里面随心所欲的实现一些其它功能，但是静态类不行。从上面这些概括中，基本可以看出二者的区别，但是，从另一方面讲，我们上面最后实现的那个单例模式，内部就是用一个静态类来实现的，所以，二者有很 大的关联，只是我们考虑问题的层面不同罢了。两种思想的结合，才能造就出完美的解决方案，就像HashMap采用数组+链表来实现一样，其实生活中很多事 情都是这样，单用不同的方法来处理问题，总是有优点也有缺点，最完美的方法是，结合各个方法的优点，才能最好的解决问题！

多谢分享