浅析Java设计模式 - 单例模式

以下是三种单例模式的代码实现,前两者用的比较多 (言外之意最后一种可以忽略)

  1 package com.signle;
  2 
  3 import java.util.HashMap;
  4 import java.util.Map;
  5 
  6 /**
  7  * 
  8  * @title 单例模式  
  9  * @Copyright Copyright (c)2016年3月9日
 10  * @Company CTC
 11  * @version 1.0
 12  * @author ejokovic
 13  * @time   上午11:21:53
 14  * @package
 15  * com.signle
 16  *
 17  */
 18 public class TestSignle {
 19     public static void main(String[] args) {
 20         Singleton s = Singleton.getInstance();
 21         Singleton s1 = Singleton.getInstance();
 22         //System.out.println(s==s1);
 23         SigletionC singleC = SigletionC.getInstance(null);  
 24         System.out.println(singleC.about()); 
 25     }
 26     
 27 }
 28 
 29 /**
 30  * 懒汉式
 31  *  是线程不安全的并发环境下很可能出现多个Singleton实例，要实现线程安全
 32  * @title  
 33  * @Copyright Copyright (c)2016年3月9日
 34  * @Company CTC
 35  * @version 1.0
 36  * @author ejokovic
 37  * @time   上午11:23:44
 38  * @package
 39  * com.signle
 40  *
 41  */
 42 class Singleton{
 43     private Singleton(){}
 44     private static Singleton Singleton;
 45     public static Singleton getInstance(){
 46         if(Singleton==null){
 47             Singleton = new Singleton();
 48         }
 49         return Singleton;
 50     }
 51 }
 52 
 53 /**
 54  * 解决懒汉式单例线程安全(一)
 55  * 在getInstance方法上加同步锁
 56  * @title  
 57  * @Copyright Copyright (c)2016年3月9日
 58  * @Company CTC
 59  * @version 1.0
 60  * @author ejokovic
 61  * @time   上午11:31:45
 62  * @package
 63  * com.signle
 64  *
 65  */
 66 class Singleton2{
 67     private Singleton2(){}
 68     private static Singleton2 Singleton;
 69     public static synchronized  Singleton2 getInstance(){
 70         if(Singleton==null){
 71             Singleton = new Singleton2();
 72         }
 73         return Singleton;
 74     }
 75 }
 76 
 77 /**
 78  * 解决懒汉式单例线程安全(二)
 79  * 双重检查锁定
 80  * @title  
 81  * @Copyright Copyright (c)2016年3月9日
 82  * @Company CTC
 83  * @version 1.0
 84  * @author ejokovic
 85  * @time   上午11:34:42
 86  * @package
 87  * com.signle
 88  *
 89  */
 90 class Singleton3{
 91     private Singleton3(){}
 92     private static Singleton3 Singleton;
 93     public static synchronized  Singleton3 getInstance(){
 94         if(Singleton==null){
 95             synchronized (Singleton3.class){
 96                 if(Singleton==null){
 97                     Singleton = new Singleton3();
 98                 }
 99             }
100         }
101         return Singleton;
102     }
103 }
104 
105 /**
106  * 解决懒汉式单例线程安全(二)
107  * 静态内部类
108  * 这种比上面1、2都好一些，既实现了线程安全，又避免了同步带来的性能影响。
109  * @title  
110  * @Copyright Copyright (c)2016年3月9日
111  * @Company CTC
112  * @version 1.0
113  * @author ejokovic
114  * @time   下午12:06:54
115  * @package
116  * com.signle
117  *
118  */
119 class Singleton4{
120     private static class LazyHolder{
121          private static final Singleton4 INSTANCE = new Singleton4();  
122     }
123     private Singleton4(){}
124     public static synchronized  Singleton4 getInstance(){
125         return LazyHolder.INSTANCE;
126     }
127 }
128 
129 /**
130  * 饿汉式单例类.在类初始化时，已经自行实例化
131  * @title  
132  * @Copyright Copyright (c)2016年3月9日
133  * @Company CTC
134  * @version 1.0
135  * @author ejokovic
136  * @time   下午12:12:23
137  * @package
138  * com.signle
139  *
140  */
141 class SigletionA{
142     private SigletionA(){}
143     private static final SigletionA sigletionA = new SigletionA();
144     public static SigletionA getInstance(){
145         return sigletionA;
146     }
147 }
148 
149 //登记式单例
150 class SigletionC{
151     private static Map<String,SigletionC> map = new HashMap<String,SigletionC>();  
152     static{  
153         SigletionC single = new SigletionC();  
154         map.put(single.getClass().getName(), single);  
155     }  
156     //保护的默认构造子  
157     protected SigletionC(){}  
158     //静态工厂方法,返还此类惟一的实例  
159     public static SigletionC getInstance(String name) {  
160         if(name == null) {  
161             name = SigletionC.class.getName();  
162             System.out.println("name == null"+"--->name="+name);  
163         }  
164         if(map.get(name) == null) {  
165             try {  
166                 map.put(name, (SigletionC) Class.forName(name).newInstance());  
167             } catch (InstantiationException e) {  
168                 e.printStackTrace();  
169             } catch (IllegalAccessException e) {  
170                 e.printStackTrace();  
171             } catch (ClassNotFoundException e) {  
172                 e.printStackTrace();  
173             }  
174         }  
175         return map.get(name);  
176     }  
177     //一个示意性的商业方法  
178     public String about() {      
179         return "Hello, I am RegSingleton.";      
180     }      
181 }

单例模式

在了解饿汉与懒汉的区别前先了解下什么是线程安全:

假如你的代码所在的进程中有多个线程在同时运行,而这些线程可能会同时执行这段代码,如果每次执行的结果和单线程中执行的结果一致且其它变量的值也和预期的一致这就是线程安全

换句话说:

一个类或者程序提供的接口对于线程来说是原子操作,或者多个线程之间切换不会导致该接口的执行结果存在差异性也就是说我们不用考虑同步的问题那就是线程安全的

饿汉式和懒汉式区别:

从名字上来说，饿汉和懒汉:

　　饿汉是当类加载时就把单例初始化完成,保证getInstance的时候,单例是已经存在的了

　　而懒汉比较懒,只有当调用getInstance的时候,才会去初始化这个单例;

从线程是否安全角度讲:

　　饿汉式天生就是线程安全的,可以直接用于多线程而不会出现问题

　　懒汉式本身是非线程安全的,为了实现线程安全有几种写法，分别是上面的1、2、3,这三种实现在资源加载和性能方面有些区别;

从资源加载和性能的角度讲:

　　　　饿汉式在类加载的同时就实例化一个静态对象出来,不管之后是否用到这个静态对象,都会占据一定的内存,但是相应的在第一次调用时的速度也会更快,因为资源已经初始化好了;

　　　　至于以上1,2,3 这三种实现又有些区别

　　　　第一种,在方法调用上加了同步,虽然线程安全了,但每次都要同步,会影响性能,毕竟大部分的情况下是不需要同步的

　　　　第二种,在getInstance方法中做了两次null检查,确保了只有第一次调用该静态对象的时候才会同步,这样也是线程安全的,同时避免了每次调用时的同步损耗;

　　　　第三种,利用了classloader机制,保证初始化instance时只有一个线程所以是线程安全的同时没有性能损耗

posted @ 2016-03-09 14:12 Djokovic 阅读(204) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Djokovic

http://www.cnblogs.com/ejokovic-core/

浅析Java设计模式 - 单例模式

公告