（@WhiteTaken）设计模式学习——单例模式

单例模式，个人理解就是，使用了这个模式，可以保证一个类只生成唯一的实例对象。就是在整个程序中，这个类只存在一个实例对象。

GoF对单例模式的定义：保证一个类，只有一个实例存在，同时提供能对该实例加以访问的全局访问方法。

客户端的代码用来测试，获取到的实例只有一个。直接上代码。

public class MainClass {
    public static void main(String[] args) {
        Person person1=Person.getPerson();//获取Person对象
        Person person2=Person.getPerson();//获取Person对象
        person1.setName("Tom");
        person2.setName("WhiteTaken");//如果两个获取的到的对象的实例，是同一实例，那么打印出来的名字应该是一样的。
        System.out.println(person1.getName());
        System.out.println(person2.getName());
    }
}

如果不是单例模式，而仅仅是创建了几个对象 ，那么两次打印的结果，将会是两个不同的名字。

而单例模式的情况，获取的到的是同一个对象，那么两次打印的结果，将是第二次赋值的结果。

单例测试结果如下。

好，上面是测试结果，那么单例模式是怎么实现的呢。

我学习到的三种单例模式的创建方法。

1.直接用final方式创建。只要类执行，就会创建这样一个对象。

代码如下。

public class Person {
    private String name;
    public static final Person perSon= new Person();//注意此处的final
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    //构造函数私有化
    private Person(){
        
    }
    //获取对象的方法，final实现
    public static Person getPerson(){
        return perSon;
    }
}

通过final关键字，保证perSon只被赋值一次，即值生成一次对象。

2.第二种方式，通过在获取对象的方法中判断person是否为null，如果不存在，则实例化person，如果存在，则直接返回person实例。

public class Person2 {
    private String name;
    private static Person2 perSon;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    //构造函数私有化
    private Person2(){
        
    }
    //获取对象的方法，单线程模式可用
    public static Person2 getPerson(){
        if(perSon==null){
            return perSon=new Person2();
        }
        return perSon;
    }
}

以上方法是实现单例模式的第二种方法，但是此种方法有一个天然的劣势，就是只适合单线程开发。

多线程的话，如果两个线程同时访问这个方法的话，返回的person对象可能会出现不一样的情况 ，那就不是单例了。

如果使用同步方法的话(synchronized)，多线程的情况下会造成线程等待，影响效率。

3.第三种方式是通过双重检查的方式实现单例。

双重判断，通过两次判断null，能够确保在多线程下，只生成一个单例。

public class Person4 {
    private String name;
    private static Person4 perSon;
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    //构造函数私有化
    private Person4(){
        
    }
    //获取对象的方法,双重检查
    public static  Person4 getPerson(){
        if(perSon==null){
            synchronized (Person4.class) {
                if(perSon==null){
                    return perSon=new Person4();
                }                
            }
        }
        return perSon;
    }
}

这样就完成单例模式的简单应用。

要想达到学以致用，真的很难，工作久了，很多东西都忘了。。。单例模式写的一个小例子，加强理解。

需要注意：只创建了一次对象。

 class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("================测试单例模式=========begin======");
            Test tst = GetAllTest.GetTest();
            tst.TestPrint();
            Test tst2 = GetAllTest.GetTest();
            tst2.TestPrint();
            Console.WriteLine("================测试单例模式=========end========");
            Console.Read();
        }
    }


    class Test
    {
        public Test(){}
        public void TestPrint()
        {
            Console.WriteLine("单例模式打印结果");
        }
    }

    class GetAllTest
    {
        private static Test ts;
        public static Test GetTest()
        {
            if(ts == null)
            {
                Console.WriteLine("创建Test对象过程");
                ts = new Test();
            }

            return ts;
        }
    }

打印结果：

好好努力，提高自己！！！