JZ-J-02

剑指offer第二题：单例模式

package ren.laughing.jianzhi;

/**
 * 饿汉式：在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。
 * 
 * @author Laughing_Lz
 * @time 2016年5月16日
 */
public class Singleton1 {
    private static final Singleton1 singleton1 = new Singleton1();// 饿汉式，static直接创建实例,节省时间但是会一直占用内存,天生线程安全
    // 私有构造函数

    private Singleton1() {

    }

    public Singleton1 getSingleton() {
        return singleton1;
    }
}

package ren.laughing.jianzhi;
/**
 * 懒汉式：在第一次调用的时候实例化自己 
 * 但是线程不安全
 * @author Laughing_Lz
 * @time 2016年5月16日
 */
public class Singleton2 {
    private static Singleton2 singleton2 = null;
    //私有构造函数
    private Singleton2(){
        
    }
    public Singleton2 getSingleton(){
        if(singleton2 == null){
            singleton2 = new Singleton2();
        }
        return singleton2;
    }
    
}

package ren.laughing.jianzhi;
/**
 * 懒汉式-修改1：在方法调用上加了同步，虽然线程安全了，但是每次都要同步，会影响性能。
 * @author Laughing_Lz
 * @time 2016年5月16日
 */
public class Singleton3 {
    private static Singleton3 singleton3 = null;
    //私有构造器
    private Singleton3() {
        
    }
    public static synchronized Singleton3 getSingleton(){//synchronized 同步  防止多个线程同时访问这个方法, static 对这个类的所有对象实例起作用
        if(singleton3 == null){
            singleton3 = new Singleton3();
        }
        return singleton3;
    }
}

package ren.laughing.jianzhi;
/**
 * 懒汉式-修改2：双重检查锁定
 * 在getSingleton中做了两次null检查，确保了只有第一次调用单例的时候才会做同步，这样也是线程安全的，同时避免了每次都同步的性能损耗
 * @author Laughing_Lz
 * @time 2016年5月16日
 */
public class Singleton4 {
    private static Singleton4 singleton4 = null;
    //私有构造器
    private Singleton4(){
        
    }
    public static Singleton4 getSingleton(){
        if(singleton4 == null){
            synchronized (Singleton4.class) {//双检锁:只有第一次调用单例时候才会同步 (Singleton4.class 锁定的一定要是类吗？ singleton4实例行不行)
                if(singleton4 ==null){
                    singleton4 = new Singleton4();
                }
            }
        }
        return singleton4;
    }
}

package ren.laughing.jianzhi;

/**
 * 静态内部类：按需创建实例★
 * Singleton4虽然通过双检锁避免了同步的性能损耗
 * 但是有可能会过早的创建实例（比如调用Singleton4中存在的静态方法，并不需要实例），降低内存的使用效率
 * 而在这里则可以实现 按需创建实例
 * @author Laughing_Lz
 * @time 2016年5月16日
 */
public class Singleton5 {
    // 私有构造器
    private Singleton5() {

    }

    public static Singleton5 getSingleton() {
        return LazyGet.SINGLETON5;// 调用内部类来获取单例
    }
    //静态内部类
    private static class LazyGet {
        private static final Singleton5 SINGLETON5 = new Singleton5();
    }
}