类的单例设计模式,

就是采取一定的方法保证在整个的软件系统中,对某个类只能存在一个对象实例。
分为懒汉式和饿汉式

饿汉式
一开始就创建了一个对象
/**
 * 饿汉式
 */
class EH{
    private EH(){

    }

    private static EH eh = new EH();

    public static EH getEh() {
        return eh;
    }
}

懒汉式
一开始不新建一个对象
class LH{
    private LH(){

    }
    private static LH lh = null;

    public static LH getBh() {
        if (lh==null){
            lh = new LH();
        }
        return lh;
    }
}

转载请注明出处：http://blog.csdn.net/mr_liabill/article/details/48374921   来自《LiaBin的博客》

单例模式很常见，在面试中也会经常直接让你写一个单例出来
单例模式写法一般分为两种，懒汉式和饿汉式


饿汉式

public class SingleTon {
    //加载类的时候会初始化static的instance，从这以后，这个static的instance对象便一直占着这段内存，永远不会被回收掉。
    private static SingleTon instance = new SingleTon();

    //将构造函数private掉，避免直接new SingleTon()
    private SingleTon() {
    }

    /**
     * 因为是单例，所以只能通过static方法来获取实例，因此必须是static的。
     * 方法实现较为简单，因为instance已经在加载类的时候被初始化好了，所以不存在多线程并发造成的问题
     */
    public static SingleTon getInstance() {
        return instance;
    }
}

优点：

不需要考虑多线程问题，因为instance是静态的，在类加载的时候就已经实例化了，同时也避免了synchronized所造成的性能问题，
缺点：
但这种方式也有点弊端，因为初始化类的时候就需要构造实例，（即便你还没有用到这个实例），因此在某些特定条件下会耗费内存。


懒汉式
方式1: 基于volatile的双重检查锁定的解决方案
为什么需要按如下这么复杂的去实现，参考有详细的解释 http://blog.csdn.net/guolin_blog/article/details/8860649

public class SingleTon {
    private static SingleTon instance = null;

    //将构造函数private掉，避免直接new SingleTon()
    private SingleTon() {
    }

    //synchronized避免多线程带来的问题，但同时效率降低，另一方面采取多重锁定，提高效率
    public static SingleTon getInstance() {
        if (null == instance) {
            synchronized (SingleTon.class) {
                if (null == instance) {
                    instance = new SingleTon();
                }
            }
        }
        return instance;
    }
}
这样写是没问题的，因为私有构造函数中没有初始化任何属性，否则的话上面的代码还需要改进


public class SingleTon {
    private static volatile SingleTon instance = null;
    private String name;

    //将构造函数private掉，避免直接new SingleTon()
    private SingleTon() {
        name = "SingleTon";
    }

    //synchronized避免多线程带来的问题，但同时效率降低，另一方面采取多重锁定，提高效率
    public static SingleTon getInstance() {
        if (null == instance) {
            synchronized (SingleTon.class) {
                if (null == instance) {
                    instance = new SingleTon();
                }
            }
        }
        return instance;
    }
}
这里为什么需要使用volatile关键字呢？

假设线程thread1走到了第15行的if判断发现instance==null成立，于是都进入了外部的if体。这时候thread1先获取了synchronized块的锁，于是thread1线程会执行第18行的instance = new SingleTon();这句代码，问题就出在这里，这条语句它不是原子性执行的。在Java里，实例化一个对象的过程简单地讲，可以分为两步1）先为instance对象分配一块内存，2）在这块内存里为instance对象里的成员变量赋值（比如第11行里为url赋值）。假设当thread1执行完第1）步而还没有执行第2）步的时候，另外一个线程thread2走到了第15行，这时候instance已经不是null了，于是thread2直接返回了这个instance对象。有什么问题呢？instance对象的初始化（变量赋值等操作）还没执行完呢！thread2里直接得到了一个没有初始化完全的对象，就有可能导致很严重的问题了。


那么volatile关键字有啥作用呢？当用volatile修饰了instance变量之后，对instance的写操作”先行发生“于对它的读操作。（这是Java虚拟机里的先行发生原则）这样就保证了，thread1中的instance变量被完全初始化之后，thread2才能读取它，当没有完成初始化时，thread2只能等会儿啦。


优点：
需要的时候才去加载，内存消耗好一些。(因为在需要的时候才加载，所以叫懒汉式)
缺点：
代码如此复杂，，还有synchronized带来的运行效率问题，调用同步方法会慢不少


方式2: 基于类初始化的解决方案
public class Singleton    
{    
    private static class SingletonHolder    
    {    
        public final static Singleton instance = new Singleton();    
    }    
   
    public static Singleton getInstance()    
    {    
        return SingletonHolder.instance;    
    }    
}

内部类的初始化是延迟的，外部类初始化时不会初始化内部类，只有在使用的时候才会初始化内部类。而Java语言规范规定，对于每一个类或接口C，都有一个唯一的初始化锁LC与之对应。也就是说，SingletonHolder在各个线程初始化的时候是同步执行的，且全权由JVM承包了。




两种延迟初始化方案总结


延迟初始化降低了初始化类或创建实例的开销，但增加了访问被延迟初始化的字段的开销。在大多数时候，正常的初始化要优于延迟初始化。如果确实需要对实例字段使用线程安全的延迟初始化，请使用上面介绍的基于volatile的延迟初始化的方案；如果确实需要对静态字段使用线程安全的延迟初始化，请使用上面介绍的基于类初始化的方案。

总结
为了省麻烦，就用恶汉式吧。但是我一般用懒汉式，比较需要的时候才加载，可以节省内存。至于synchronized引起的效率问题，基本很少有这样的场景，因为很少有两个线程并发调用getInstance方法。

单件模式用途：
单件模式属于工厂模式的特例，只是它不需要输入参数并且始终返回同一对象的引用。
单件模式能够保证某一类型对象在系统中的唯一性，即某类在系统中只有一个实例。它的用途十分广泛，打个比方，我们开发了一个简单的留言板，用户的每一次留言都要将留言信息写入到数据库中，最直观的方法是没次写入都建立一个数据库的链接。这是个简单的方法，在不考虑并发的时候这也是个不错的选择。但实际上，一个网站是并发的，并且有可能是存在大量并发操作的。如果我们对每次写入都创建一个数据库连接，那么很容易的系统会出现瓶颈，系统的精力将会很多的放在维护链接上而非直接查询操作上。这显然是不可取的。
如果我们能够保证系统中自始至终只有唯一一个数据库连接对象，显然我们会节省很多内存开销和cpu利用率。这就是单件模式的用途。当然单件模式不仅仅只用于这样的情况。在《设计模式：可复用面向对象软件的基础》一书中对单件模式的适用性有如下描述：
1、当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。
2、当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。
下面对单件模式的懒汉式与饿汉式进行简单介绍：
1、饿汉式：在程序启动或单件模式类被加载的时候，单件模式实例就已经被创建。
2、懒汉式：当程序第一次访问单件模式实例时才进行创建。
如何选择：如果单件模式实例在系统中经常会被用到，饿汉式是一个不错的选择。
反之如果单件模式在系统中会很少用到或者几乎不会用到，那么懒汉式是一个不错的选择。
饿汉模式demo：
public Simple(){
private static Single a=new Single();
private Single(){
}
public static Simple getSimple(){
return s;
}
return s;
}
一般用于枚举法：
enum Single {
Single;
private Single() {
}
public void print(){
System.out.println("hello world");
}
}
public class SingleDemo {
public static void main(String[] args) {
Single a = Single.Single;
a.print();
}
懒汉模式 demo：
class Single{
private static Single s = null;
public Single() {
}
if (s == null)
s = new Single();
return s;
}
}
懒汉模式在使用时，容易引起不同步问题，所以应该创建同步"锁",demo如下
class Single1 {
private static Single1 s = null;
public Single1() {
}
//同步函数的demo
public static synchronized Single1 getInstance() {
if (s == null)
s = new Single1();
return s;
}
//同步代码快的demo加锁，安全高效
public static Single1 getInStanceBlock(){
if(s==null)
synchronized (Single1.class) {
if(s==null)
s = new Single1();
}
return s;
}
}

关于java的单例模式，懒汉式和饿汉式是较为常见的单例模式。
懒汉式是占内存空间少但是相对而言用时比较多，饿汉式是占内存空间大但是相对而言用时比较少。
其中懒汉式：
package com.qf.singleton;



public class MySingletonLanhan {
//设置静态变量

private static MySingletonLanhan mySingletonLanhan=null;

private MySingletonLanhan(){
System.out.println("懒汉式的构造方法");

}

public static MySingletonLanhan getInstance() {
if (mySingletonLanhan==null) {
System.out.println("说明没有创建~~·");
mySingletonLanhan=new MySingletonLanhan();
}
else {
System.out.println("说明已经创建了");
}
return mySingletonLanhan;


}





}



饿汉式
package com.qf.singleton;



public class MySingletonEHan {

private static MySingletonEHan mySingletonEHan=new MySingletonEHan();

private MySingletonEHan(){
System.out.println("饿汉式的构造方法");

}

public static MySingletonEHan getInstance() {
System.out.println("饿汉式创建成功！！！！");
return mySingletonEHan;

}



}