单例设计模式

　　单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。 这样的模式有几个好处： 某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。 省去了new操作符，降低了系统内存的使用频率，减轻GC(垃圾回收机制)压力。 有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。（比如一个军队出现了多个司令员同时指挥，肯定会乱成一团），所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程。

　　首先我们写一个简单的单例类： 我们如果保证类在内存中只有一个对象呢?

　　　　1:为了控制该类对象的建立,不让其他的类创建该类的对象.

　　　　2:在本类中应该提供一个本类对象.

　　　　3:提供公共的方式供别人访问这个对象.

　　代码如何实现呢？

　　　　1、构造函数私有化，防止其他类创建该类对象

　　　　2、在本类中，通过new关键字创建一个对象

　　　　3、提供一个public方法，对外访问

package singletonPattern;
//饿汉式,拿来就用
public class SingletonPatternDemo {
    private String name;
    private int age;
    //2、在本类中，通过new关键字创建一个对象
    private static SingletonPatternDemo spd = new SingletonPatternDemo();
    //1.构造函数私有化,防止其他类创建该对象
    private SingletonPatternDemo(){
        super();
    }
    //3、提供一个public方法，对外访问
    //为了其他人 通过类名调用，所以static
    public static SingletonPatternDemo getSingletonPatternDemo(){
        return spd;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

}

package singletonPattern;
//饱汉式  拿来以后先比对一下,然后再决定用不用,注意线程问题
public class SingletonPatternTest {
    private String name;
    private int age;
    static //2、在本类中，通过new关键字创建一个对象让类加载时先不创建对象
    SingletonPatternTest spt = null;
    //1.构造函数私有化,防止其他类创建该对象
    private SingletonPatternTest(){
        super();
    }
    //3、提供一个public方法，对外访问
    //为了其他人 通过类名调用，所以static
    /*注意饱汉式可能会出现多线程的问题,当一个线程调用此方法执行到if判断完,并返回true,然后线程被挂了起来,此时另一个线程进来
     * 判断然后返回true,依次进行,new对象,此时堆中已经存在一个单例对象,被挂起来那个线程再进来,再new对象,此时会出现并发的问题,JVM中就可能出现多个对象
     * 怎么避免这种情况出现呢,同步机制,使用同步方法
     * */
    public static synchronized SingletonPatternTest getSingletonPatternTest(){
        if(spt == null){
            spt = new SingletonPatternTest();
        }
        return spt;
    }
}

package singletonPattern;
/*
 * 首先我们写一个简单的单例类：
    我们如果保证类在内存中只有一个对象呢?
    1:为了控制该类对象的建立,不让其他的类创建该类的对象.
    2:在本类中应该提供一个本类对象.
    3:提供公共的方式供别人访问这个对象.

    代码如何实现呢？
    1、构造函数私有化，防止其他类创建该类对象
    2、在本类中，通过new关键字创建一个对象
    3、提供一个public方法，对外访问

 */
public class SingletonTestClass {
    public static void main(String[] args) {
        //创建单例对象
        SingletonPatternDemo psd1 = SingletonPatternDemo.getSingletonPatternDemo();
        SingletonPatternDemo psd2 = SingletonPatternDemo.getSingletonPatternDemo();
        SingletonPatternDemo psd3 = SingletonPatternDemo.getSingletonPatternDemo();
        //比较获取的三个对象是不是同一个对象
        if((psd1==psd2)&&(psd2==psd3)){
            System.out.println("单例模式是在JVM中只创建一个对象!");
        }else {
            System.out.println("单例失败!");
        }
        //饱汉式创建单例对象
        SingletonPatternTest spt1 = SingletonPatternTest.getSingletonPatternTest();
        SingletonPatternTest spt2 = SingletonPatternTest.getSingletonPatternTest();
        SingletonPatternTest spt3 = SingletonPatternTest.getSingletonPatternTest();
        if((spt1==spt2)&&(spt2==spt3)){
            System.out.println("单例模式是在JVM中只创建一个对象!");
        }else {
            System.out.println("单例失败!");
        }
    }
}

两种单例设计模式的区别？

　　第一种（饿汉式）：对象随着类的加载而创建

　　第二种（懒汉式）：需要使用的时候，再创造对象，以后使用的是同一个对象。

使用场合:

　　工作的时候： 第一种

　　面试的时候： 第二种 原因： 第二种，会出现线程安全问题