设计模式之单例模式

（1）    单例模式

保证每个类只有一个实例，提供一个全局访问点。

主要使用的单利模式有两种懒汉式和饿汉式

 

/**
 * 饿汉式设计模式
 */
public class Singleton {
    //私有构造方法，为了使得他不能new出对象
    private Singleton(){}
    //类加载的时候进进行了对象的创建，所以该方式是线程安全的
   private static final Singleton instace=new Singleton();
    public static Singleton getInstace(){
        return instace;
    }
}

/**
 * 懒汉式设计模式
 * 该写法存在线程安全问题，在多线程情况下，会创建多个实例，懒汉式使用了懒加载的方式
 */
public class Singleton1 {
    //外界不能造对象 把无参构造方法私有
    private Singleton1(){

    }
    private static   Singleton1 instance=null;
    public static Singleton1 getInstace(){
        if (instance==null){
            instance=new Singleton1();
        }
        return instance;
    }
}

懒汉式有以下三种解决多线程问题方法

/**
 * 懒汉式设计模式
 *  该方式解决了多线程问题，但是并不高效，在任何时候只有一个线程可以使用该实例
 */
public class Singleton1 {
    //外界不能造对象 把无参构造方法私有
    private Singleton1(){

    }
    private static   Singleton1 instance=null;
    public static synchronized Singleton1 getInstace(){
        if (instance==null){
            instance=new Singleton1();
        }
        return instance;
    }
}
/**
 *   懒汉式设计模式
 *   双重锁检验
 */
public class Singleton1 {
    //外界不能造对象 把无参构造方法私有
    private Singleton1(){

    }
    private static  volatile Singleton1 instance=null; //保证了变量的可见性，并且不被虚拟机进行优化
    public static  synchronized Singleton1 getInstace(){
        if (instance==null){
          synchronized (Singleton1.class){
              //因为这里有可能会有所一个线程得到锁之后刚创建了对象，释放了锁，然后另一个线程同时得到了锁
              //走到这里，如果不判断为空可能会建立两个对象，所以说双重锁检验还是比较好的方式。
              if (instance==null){
                  instance=new Singleton1();
              }
          }
        }
        return instance;
    }
}

/**
 *   懒汉式设计模式
 *    使用静态内部类实现
 *    这种写法保证了线程安全问题，该内部类是私有的，只有加载的时候才会创建对象，同时读取实例的时候不会有性能缺陷
 */
public class Singleton1 {

    private static class SingletonInner{
     private static final Singleton1 intance=new Singleton1();
    }

    private Singleton1(){}
    public static final Singleton1 getInstance(){
        return SingletonInner.intance;
    }
}