public class Singleton {  
    private static Singleton singleton = new Singleton();  
    private Singleton(){}  
    public static Singleton getInstance(){  
        return singleton;  
    }  
}

懒汉式单例

public class Singleton {  
    private static Singleton singleton;  
    private Singleton(){}  
      
    public static synchronized Singleton getInstance(){  
        if(singleton==null){  
            singleton = new Singleton();  
        }  
        return singleton;  
    }  
} 

解决问题的办法是为指示类是否已经实例化的变量提供一个相互排斥锁(详见双重锁单例，尽管这样会减少效率)。

懒汉式适合单线程。多线程情况下假设在创建实例对象时不加上synchronized则会导致对对象的訪问不是线程安全的。

从实现方式来讲他们最大的差别就是懒汉式是延时载入, 
他是在须要的时候才创建对象,而饿汉式在载入类时创建实例。 
 饿汉式无需关注多线程问题、写法简单明了、能用则用。

可是它是载入类时创建实例、所以假设是一个工厂模式、缓存了非常多实例、那么就得考虑效率问题，由于这个类一载入则把全部实例无论用不用一块创建。

懒汉式的长处是延时载入、缺点是应该用同步。

避免对共享资源的多重占用。
能够全局訪问。


适用场景：

创建对象时耗时过多或者耗资源过多，但又经经常使用到的对象。

有状态的工具类对象。
频繁訪问数据库或文件的对象。
以及其它我没用过的全部要求仅仅有一个对象的场景。

单例模式注意事项：
仅仅能使用单例类提供的方法得到单例对象，不要使用反射，否则将会实例化一个新对象。
不要做断开单例类对象与类中静态引用的危急操作。
多线程使用单例使用共享资源时。注意线程安全问题。

双重锁形式单例(懒汉式进阶版，哈哈)

 public static class Singleton{
    private static Singleton instance=null;
    private Singleton(){
        //do something
    }
    public static Singleton getInstance(){
        if(instance==null){
            synchronized(Singleton.class){
                if(null==instance){
                    instance=new Singleton();
                }
            }
        }
        return instance;
    }
}

Public class Singleton{
    Private Singleton(){};
    Public static class Singleton1{
        Private static final Singleton instance = new Singleton();
}    
    Public static Singleton getInstance(){
        Return Singleton1.instance;
}
}

这样就能保证在第一次调用getInstance（）方法时，才会去初始化instance实例，并且该实例被定义为static，仅仅会被初始化一次。(这样的方法是网上看的，我还未用过，以后能够试试，哈哈)