（@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;
         }
     }

打印结果：

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