单例模式(简单总结)

1.单例就是—–该类只能返回一个实例。
2.单例所具备的特点：
2.1.私有化的构造函数
2.2.私有的静态的全局变量
2.3.公有的静态的方法

3.懒汉式单例—(线程不安全的)

//懒汉式单例类.在第一次调用的时候实例化自己   
public class Singleton {  
    private Singleton() {}  //私有化的无参构造函数
    private static Singleton single=null;  //私有的静态的全局变量
    //公有的静态的方法   
    public static Singleton getInstance() {  
         if (single == null) {    
             single = new Singleton();  
         }    
        return single;  
    }  
}  

4.饿汉式单例—-(由于有私有的静态的常量对象,所以就是线程安全的)

//饿汉式单例类.在类初始化时，已经自行实例化   
public class Singleton1 {  
    private Singleton1() {} //私有化的无参构造函数
    private static final Singleton1 single = new Singleton1();  //私有的静态的常量对象
    //共有的静态的方法  
    public static Singleton1 getInstance() {  
        return single;  
    }  
}  

5.懒汉式和饿汉式的区别
从名字上来说，饿汉和懒汉，
饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了，
而懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例。

6.饿汉式实现线程安全的三种方式
6.1在getInstance方法上加同步

public static synchronized Singleton getInstance() {  
         if (single == null) {    
             single = new Singleton();  
         }    
        return single;  
}

6.2双重判定锁

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

6.3静态内部类

public class Singleton {    
    private static class LazyHolder {    
       private static final Singleton INSTANCE = new Singleton();    
    }    
    private Singleton (){}    
    public static final Singleton getInstance() {    
       return LazyHolder.INSTANCE;    
    }    
}