Java设计模式--单例设计模式：饿汉式，懒汉式，双重校验锁方式

单例设计模式：保证类在内存中只有一个对象。

如何保证类在内存中只有一个对象呢？

       (1)控制类的创建，不让其他类来创建本类的对象。private

       (2)在本类中定义一个本类的对象。Singleton s;

       (3)提供公共的访问方式。

        public static Singleton getInstance(){return s}

单例写法两种：

(1)饿汉式 开发用这种方式

//饿汉式
class Singleton {
    //1,私有构造函数
    private Singleton(){}
    //2,创建本类对象
    //如果创建非静态成员变量，就只能用对象调用，但这里已经没法创建对象了，所以没法调用。
    //静态的话就可以用类名.  来调用
    private static Singleton s = new Singleton();
    //3,对外提供公共的访问方法
    public static Singleton getInstance() {
        return s;
    }
}

public class test {

    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
    }
}

(2)懒汉式 (单例的延迟加载模式) 面试写这种方式。

多线程的问题？

//懒汉式,单例的延迟加载模式
class Singleton {
    //1,私有构造函数
    private Singleton(){}
    //2,声明一个本类的引用
    private static Singleton s;
    //3,对外提供公共的访问方法
    public static Singleton getInstance() {
        if(s == null)
            /*
            *这里存在多线程问题：假如线程1进入，s == null，但线程被线程2抢走，线程1等待
            *线程2进入，s == null，但线程又被线程1抢走，线程2等待，于是线程1,2都会创建对象
            *就不是到哪里模式了
            */
            s = new Singleton();
        return s;
    }
}

public class test {

    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
    }
}

**饿汉式与懒汉式的区别：

1）饿汉式是空间换时间，懒汉式是时间换空间

2）在多线程访问时，饿汉式不会创建多个对象

 

(3)双重校验锁方式（懒汉式）

public class Singleton { 

    private volatile static Singleton uniqueInstance; 
    private Singleton() { }

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