单例设计模式

一，设计模式的由来:

　　设计模式的概念首先来源于其它行业：建筑业，在早起建房子的时候，肯定是经验缺乏、显得杂乱无序的，这就会造成很多问题，在行业发展过程，通过不断的经验积累，前辈们针对这些问题提出了合理解决方案，这就是设计模式，参照设计模式往往可以解决很多问题，在计算机编程方面，也会出现类似问题，所以牛人们把这些解决问题的方案进行归类和总结，形成了面向对象编程的23种设计模式。

1.11，什么是单例设计模式:

　　保证类在内存中只有一个对象。

1.1.2，饿汉式 开发用这种方式:

    　　　　//饿汉式
            class Singleton {
                //1,私有构造函数
                private Singleton(){}
                //2,创建本类对象
                private static Singleton s = new Singleton();
                //3,对外提供公共的访问方法
                public static Singleton getInstance() {
                    return s;
                }
                
                public static void print() {
                    System.out.println("11111111111");
                }
            }

1.1.3，懒汉式 面试写这种方式。多线程的问题？
　     懒汉式,单例的延迟加载模式

            class Singleton {
                //1,私有构造函数
                private Singleton(){}
                //2,声明一个本类的引用
                private static Singleton s;
                //3,对外提供公共的访问方法
                public static Singleton getInstance() {
                    if(s == null)
                        //线程a进入等待，线程b进入等待，线程ab假如苏醒就会创建俩对象这就不是单例设计模式了
                        s = new Singleton();
                    return s;
                }

1.1.4，利用final完成的单例设计模式:

            class Singleton {
                private Singleton() {}
            
                public static final Singleton s = new Singleton();//final是最终的意思,被final修饰的变量不可以被更改
            }

1.1.5，懒汉式同步锁（懒汉式线程不安全的解决方案）:

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

问题：每次调用getInstance时都会判断锁，这样会降低程序的效率。注：锁（Singleton.class）该类所属的字节码文件对象。

1.1.6，懒汉式双重校验锁:

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

假如单单去讲上面的例子可能会有很多同学不明白，下面写一个平时开发用的单例设计模式的例子:

1.2.2，使用前:

public class Demo2_Singleton {
    public static void main(String[] args) {
        Studen s = new Studen();
        s.setName("JAVA大法好");
        s.setAge(100);
        System.out.println(s.getName()+"~~~~~~"+s.getAge());
    }
}
class Studen{
    private String name;
    private int age;
    public Studen() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Studen(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    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;
    }
}

//编译结果：JAVA大法好~~~~~~100

1.2.3使用后:

public class Demo2_Singleton {
    public static void main(String[] args) {
//        这样就可以看的出单例设计模式的好处,本类只存在一个实例,获取对象的属性不用new了,大大节省了内存空间，保证了对象的唯一性
        Studen s = Studen.getInstance();
        s.setName("JAVA大法好");
        s.setAge(100);
        System.out.println(s.getName()+"~~~~~~"+s.getAge());
    }
}
class Studen{
    private String name;
    private int age;
    private  Studen() {}//私有构造方法
    private static Studen instance = new Studen();//2.本类中创建该类的对象
    public static Studen getInstance(){//3.创建一个方法，向外部提供该类的对象
        return instance;
    }
    
    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;
    }
}

//编译结果：JAVA大法好~~~~~~100

二，饿汉式与懒汉式的区别:

　 1.6.1：懒汉式是空间换时间,懒汉式是时间换空间
　 1.6.2：在多线程访问中,饿汉式不会创建多个对象,而懒汉式有可能会创建多个对象