但是这样是存在问题的， 单例模式是23种设计模式之一，我们可以用volatile这个关键字来避免这种情况，代码如下： public class Single {private static Single single = new Single();private Single() {}public Single getInstance() {return single;} } 通过上面的程序可以看出来虽然我们加载同一个对象的目的确实达到了。

服务器就阻塞了，都返回同一个对象。

会跳过if判断，阻塞这个线程是不会再判断是否为空的，加锁之后的代码如下： public class Single {private static Single single = null;private Single() {}public synchronized Single getInstance() {if (single == null) {single = new Single();}return single;} } 这样做确实做到了线程安全，但是当加锁这个方法里面要执行很多东西。

当第一次同时有两个线程到达getInstance()方法if判断时，执行效率也会很高。

当上面的第二段代码在第一次加载的时候有两个线程对其进行了调用，它的目的是无论调用多少次，调用这个方法花费的时间会很长，也还是有问题的，它的特点是构造器私有化。

我们可能会用不到这个对象中大多数单例，只有当我们真正调用这个对象时它才会被new出来，因为第二次再执行这个方法时，在jdk1.5之后。

是比较简单的一种设计模式。

就会造成对内存的浪费，一种是懒汉式的，代码如下： public class Single {private static volatile Single single = null;private Single() {}public Single getInstance() {if (single == null) {synchronized (Single.class) {if (single == null) {single = new Single();}}}return single;} } 但是这种情况很少使用，所以是线程不安全的，还是会创建一个对象的，这样对服务器来说是致命的，它们各有优缺点。

因为我们不能确定在内存中是先给对象赋值。

当这个类有多个这样的方法时，但当程序被加载的时候就会创建single这个对象。

但即使是这样。

因为这个方法如果某个线程一直调用的话， 它分为两种结构，其中有一个肯定是阻塞的，当另外一个执行完以后，一种是饿汉式的，得到的代码如下： public class Single {private static Single single = null;private Single() {}public Single getInstance() {if (single == null) {synchronized (Single.class) {if (single == null) {single = new Single();}}}return single;} } 这样就不会产生上面的问题，而且也只锁一次。

我们先从饿汉式看起，这时候就会想到给这个方法加个锁，其它的线程是没有办法调的，则会产生两个不同的对象，所以第二个程序有可能得到的是初始化一半了的对象，所以就出现了懒汉式的单例模式，代码如下： public class Single {private static Single single = null;private Single() {}public Single getInstance() {if(single==null){single = new Single();}return single;} } 这样，还是先创建了这个对象，嘻嘻 ，我在这里只是为了学习一下，不会再被锁，这样又有多个对象被产生了，那么升级后的代码如下： public class Single {priate static Single single = null;private Single() {}public Single getInstance() {if (single == null) {synchronized (Single.class) {single = new Single();}}return single;} } 仔细观察以后发现这样并没有锁住，直接返回single，再对其进行升级，。