单例设计模式

设计模式：对问题行之有效的解决方式。其实它是一种思想。

1，单例设计模式

　　解决的问题：就是可以保证一个类在内存中的对象唯一性。

 

必须对于多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性。

 

如何保证对象的唯一性呢？

1，不允许其他程序用new创建该类对象；

2，在该类创建一个本类实例；

3，对外提供一个方法让其他程序可以获取该对象。

 

步骤：

1，私有化该类的构造函数；

2，通过new在本类中创建一个私有静态本类对象；

3，定义一个共有静态方法，将创建的对象返回。

public class TestSingleton {
    public static void main(String[] args){
        Test t1 =  Test.getInstance();
        Test t2 =  Test.getInstance();
        t1.setNum(10);
        t2.setNum(15);
        System.out.println(t1.getNum());
        System.out.println(t2.getNum());
    }
}

}
class Test{
    private int num;
15     private Test(){}
16     private static Test t = new Test();
17     public static Test getInstance(){
18         return t;
19     }
    public void setNum(int num){
        this.num = num;
    }
    public int getNum(){
        return num;
    }
}

//懒汉式
//类加载进来，没有对象，只有调用了getInstance方法时，才会创建对象。
//延迟加载形式

class Single2{
    private static Single2 s = null;
    private Single2(){}
    public static Single2 getInstance(){
        if(s == null){
            s = new Single2();
        }
        return s;
    }
}

当懒汉式的getInstance方法要放入到多线程的run方法中的时候，有三种方法

1，在static后面加上synchronized；这样可以达到目的，但是会降低执行效率，因为同步外的线程都会判断同步锁。

2，改成synchronized(Single2.class){线程执行代码}同步代码块的形式；这样和第一个方法没什么区别；

3，改成if(s==null){synchronized(Single2.class){线程执行代码}}；这样才是最佳方案，多加一个if(s==null)可以提高执行的效率，解决了第一个方法的效率问题。

//饿汉式
//类一加载，对象就已经存在了
class Single{
    private static Single s = new Single();
    private Single(){
        
    }
    public static Single getInstance(){
        return s;
    }
}