首页 > 代码库 > (@WhiteTaken)设计模式学习——单例模式

(@WhiteTaken)设计模式学习——单例模式

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

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

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

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

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

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

单例测试结果如下。

技术分享

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

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

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

代码如下。

 1 public class Person {
 2     private String name;
 3     public static final Person perSon= new Person();//注意此处的final
 4     public String getName() {
 5         return name;
 6     }
 7 
 8     public void setName(String name) {
 9         this.name = name;
10     }
11     //构造函数私有化
12     private Person(){
13         
14     }
15     //获取对象的方法,final实现
16     public static Person getPerson(){
17         return perSon;
18     }
19 }

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

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

 1 public class Person2 {
 2     private String name;
 3     private static Person2 perSon;
 4     public String getName() {
 5         return name;
 6     }
 7     public void setName(String name) {
 8         this.name = name;
 9     }
10     //构造函数私有化
11     private Person2(){
12         
13     }
14     //获取对象的方法,单线程模式可用
15     public static Person2 getPerson(){
16         if(perSon==null){
17             return perSon=new Person2();
18         }
19         return perSon;
20     }
21 }

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

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

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

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

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

 1 public class Person4 {
 2     private String name;
 3     private static Person4 perSon;
 4     public String getName() {
 5         return name;
 6     }
 7 
 8     public void setName(String name) {
 9         this.name = name;
10     }
11     //构造函数私有化
12     private Person4(){
13         
14     }
15     //获取对象的方法,双重检查
16     public static  Person4 getPerson(){
17         if(perSon==null){
18             synchronized (Person4.class) {
19                 if(perSon==null){
20                     return perSon=new Person4();
21                 }                
22             }
23         }
24         return perSon;
25     }
26 }

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

 

(@WhiteTaken)设计模式学习——单例模式