您的位置: 首页  >  文章  >  设计模式之单例模式(Singleton)

设计模式之单例模式(Singleton)

分类: 文章 • 2024-01-05 20:15:04

单例模式是一种常用的设计模式,可以保证对象在JVM中只有一个实例存在，这样做的好处可以不用重复的创建类对象，节省一笔很大的开销，而且可以减轻GC压力。常见的创建模式有懒汉模式和饿汉模式。但是如果考虑到不同场景，设计有很大差别。

首先简单一个简单的图示例:

设计模式之单例模式(Singleton)

懒汉模式:(类加载时，不立即创建实例，所以加载类速度快，但是获取实例较慢)

[java]view plain copy
 print?
  1. public class SingIeton {  
  2.     /* 
  3.      * 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载 
  4.      */  
  5.     private static SingIeton instance = null;  
  6.     /* 
  7.      *私有构造方法,防止被实例化 
  8.      */  
  9.     private SingIeton(){  
  10.   
  11.     }  
  12.     /*静态工程方法,创建实例*/  
  13.     public static SingIeton getInstance(){  
  14.         if(instance == null){  
  15.             instance = new SingIeton();  
  16.         }  
  17.         return instance;  
  18.     }  
  19.   
  20. }  

饿汉模式:(类加载时，创建实例，加载速度慢，但是获取实例快)


[java]view plain copy
 print?
  1. public class SingIeton {  
  2.    
  3.     private static SingIeton instance = new SingIeton();  
  4.     /* 
  5.      *私有构造方法,防止被实例化 
  6.      */  
  7.     private SingIeton(){  
  8.   
  9.     
  10.     public static SingIeton getInstance(){  
  11.         
  12.         return instance;  
  13.     }  
  14.   
  15. }  

如果放在多线程下，上面的写法显然是不安全的，要考虑到同步问题:


[java]view plain copy
 print?
  1. public class SingIeton {  
  2.     /* 
  3.      * 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载 
  4.      */  
  5.      private static SingIeton instance = null;  
  6.     /* 
  7.      *私有构造方法,防止被实例化 
  8.      */  
  9.     private SingIeton(){  
  10.   
  11.     }  
  12.     /*静态工程方法,创建实例*/  
  13.   
  14.     public  static synchronized SingIeton getInstance(){  
  15.         if(instance == null){  
  16.             instance = new SingIeton();  
  17.         }  
  18.         return  instance;  
  19.   
  20.     }  
  21.      
  22. }  
上面的写法解决同步问题，但是有一个问题，每次调用getInstance()都要给对象加锁，这样明显效率不是最低，下面：


[java]view plain copy
 print?
  1. /** 
  2.  * Created by diy_os on 2016/10/2. 
  3.  */  
  4. public class SingIeton {  
  5.     /* 
  6.      * 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载 
  7.      */  
  8.      private static SingIeton instance = null;  
  9.     /* 
  10.      *私有构造方法,防止被实例化 
  11.      */  
  12.     private SingIeton(){  
  13.   
  14.   }  
  15.      
  16.     public static  SingIeton getInstane(){  
  17.         if(instance == null){  
  18.             synchronized (instance){  
  19.                 if(instance == null){  
  20.                     instance = new SingIeton();  
  21.                 }  
  22.             }  
  23.         }  
  24.         return instance;  
  25.     }  
  26.       
  27. }  

上面的写法在一定程度上提升了性能，但不是最优的，单例模式需要结合实际需求找到适合的解决方法，有一定的难度。



来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/29876893/viewspace-2140450/，如需转载，请注明出处，否则将追究法律责任。

转载于:http://blog.itpub.net/29876893/viewspace-2140450/

相关推荐