如此使用单例模式！

最近拿到一个项目，大致扫了一下，发现大多数的代码都是如下的结构：

public class User {
	private String userName;
	
	public String getUserName() {
		return userName;
	}
	
	public void setUserName(String userName) {
		this.userName = userName;
	}
}

public class UserRule { 
	private static UserRule instance = null; 
	
	public static UserRule getInstance() { 
		if (instance == null) { 
			instance = new UserRule(); 
		} 
		return instance; 
	}
	
	public User AddUser(String userName) {
		// add a new user operations
	}
} 

先不说问题，来看看这样做的一些可取之处：
1、设计简单。系统的设计在这样的结构下其实就是贫血类的设计，剩下的就是在Rule类中增加相应的方法。
2、各个模块的开发可以同时进行。各人根据要求定义好模块相应的类，剩下的就是缺啥补啥了。

然后说问题：
1、首先该单例实现就有问题了，这样的实现并不能保证线程安全。不过好在其实这个UserRule本身也没有字段之类的东西，不单例其实也没多大影响。所以我想这个单例丢在这里估计只是为了写代码的时候方便点。
2、这种做法应对需求变化的结果就是不断的在UserRule中添加新的满足需求的方法，最后天知道这个方法到底干嘛的。
3、我想这样的系统应该性能上很差了，可奇怪客户用到现在居然没一点性能上的反馈。不过性能这块只是我的一个感觉，还没有对这样的系统做一个压力测试，无法提供实际情况。

不知道还有没有其他的缺点，欢迎各位来分析分析。

评论

48 楼 melode11 2009-01-24  

zozoh 写道

#     public static UserRule getInstance() {  
#         if (instance == null) {  
#             instance = new UserRule();  
#         }  
#         return instance;  
#     }

应该写成
public static UserRule getInstance() {  
if (instance == null) {
synchronized(UserRule.class){
if (instance == null){
instance = new UserRule();
}
}
}  
return instance;  
}

以保证多个线程访问的安全

DCL在java不work的，你这个依然不安全。IBM的wiki上有讲

47 楼 lgx522 2009-01-24  

事实证明以Spring为代表的DI多年来表现非常出色，大家真的没有必要再去折腾什么singleton或是factory。

46 楼 pipilu 2009-01-24  

mydolors 写道

1 public class UserRule {   
2    private static UserRule instance = null;   
3      
4    public static UserRule getInstance() {   
5        if (instance == null) {   
6            instance = new UserRule();   
7        }   
8        return instance;   
9    }  
10      
11   public User AddUser(String userName) {  
12        // add a new user operations  
13   }  
14 } 


这么写存在安全隐患，在一定的情况下会抛出异常。
例如：
前提：大家调用 UserRule.getInstance() 方法获得UserRule的实例。
1.假设UserRule第一次加载，当2个线程 a , b同时调用getInstance()方法初始instance的时候.
线程a执行到6行，在构造函数执行之前，使实例成为非 null,线程a停止。就是这里.
这时线程b 抢占线程，执行到第5行的时候，条件为假，返回insatcne,一个构造完整但部分初始化了的 insatcne对象。 那么客户端就拿到一个还没有完全实例化的对象. 结果可想而之了。

不过我想这种情况发生的概率应该极低吧？

这里我有个疑问：如果UserRule没有初始化完成，会把引用传给instance么？
这里面容易出现的一个问题是可能会传出了两个实例。关于上面说的问题倒没想过。
---------------------------------------------------------------
哦，我明白了，楼上说的没错。
大家可以看一下这篇文章：http://www.ibm.com/developerworks/cn/java/j-dcl.html

45 楼 luanma 2009-01-23  

LS的“if (instance == null) {” 放在synchronized块外面还是错误的用法

44 楼 zozoh 2009-01-23  

mydolors 写道

zozoh 写道

#     public static UserRule getInstance() {  
#         if (instance == null) {  
#             instance = new UserRule();  
#         }  
#         return instance;  
#     }

应该写成
1 public static UserRule getInstance() {  
2 if (instance == null) {
3 synchronized(UserRule.class){
4 if (instance == null){
5 instance = new UserRule();
6 }
7 }
8 }  
9 return instance;  
10}

以保证多个线程访问的安全

这么写存在缺陷。具体如下：
线程a进入该方法，由于第一次初次初始化，所以很顺利的进入到第5行，在构造函数执行之前，使实例成为非 null,停止。
b线程抢占线程，执行到2行的时候，由于instance非空，所以返回一个构造完整但部分初始化了的instance 对象。
结果可向而知。
双重检查成例，在java中是不能实现的。阎宏的《java设计与模式》233页中有提到。

如果构造函数比较复杂，楼主害怕出现这个问题，上面的写法应该换成

public static UserRule getInstance() {   
       if (instance == null) {
		synchronized(UserRule.class){
			if (instance == null){
				UserRule newRule = new UserRule();			
                                instance = newRule;
			}
		}
	}   
	return instance;   
}

43 楼 szhnet 2009-01-23  

UserRule这个类中又没有什么大对象之类的，所以没必要延时加载，如果非要延时可以用内部类

public class UserRule {
	private UserRule() {
		
	}
	
	private static class LazyHolder {
		public static UserRule userRule = new UserRule();
	}
	
	public static UserRule getInstance() { 
		return LazyHolder.userRule;
	}
}

42 楼 narry 2009-01-23  

daaoke 写道

synchronized　性能损失的高。
还是要用变量的　volatile　来锁住比较好。
另外一定要加　私有的构造函数

volatile只是保证内存可见性，不能替代锁

41 楼 daaoke 2009-01-23  

synchronized　性能损失的高。
还是要用变量的　volatile　来锁住比较好。
另外一定要加　私有的构造函数

40 楼 laozhijia 2009-01-22  

不就是没线程安全吗,能给个说明.如果这样会有什么问题,线程安全了,性能就不行了

39 楼 duduli 2009-01-22  

这是个典型的单例模式，如果采用线程的话，性能会下降很多。

38 楼 taelons 2009-01-22  

不是单例的，而且UserRule里有一个静态局部变量UserRule，很奇快的写法，getInstance()应该放在一个工厂类里

37 楼 huazsh 2009-01-22  

ych516 写道

kimmking 写道

引用

性能是测试出来的 不是你想出来的

赞这句

同意哈～

同意

36 楼 luanma 2009-01-22  

这个贴比较水。

另一种写法

public class UserRule {   
    private static final UserRule instance = new UserRule();   
    private UserRule() {}

    public static UserRule getInstance() {   
        return instance;   
    }  
    ... ...
}  

35 楼 mydolors 2009-01-22  

zozoh 写道

#     public static UserRule getInstance() {  
#         if (instance == null) {  
#             instance = new UserRule();  
#         }  
#         return instance;  
#     }

应该写成
1 public static UserRule getInstance() {  
2 if (instance == null) {
3 synchronized(UserRule.class){
4 if (instance == null){
5 instance = new UserRule();
6 }
7 }
8 }  
9 return instance;  
10}

以保证多个线程访问的安全

这么写存在缺陷。具体如下：
线程a进入该方法，由于第一次初次初始化，所以很顺利的进入到第5行，在构造函数执行之前，使实例成为非 null,停止。
b线程抢占线程，执行到2行的时候，由于instance非空，所以返回一个构造完整但部分初始化了的instance 对象。
结果可向而知。
双重检查成例，在java中是不能实现的。阎宏的《java设计与模式》233页中有提到。

34 楼 czqyr 2009-01-22  

嗯，楼上的我明白了。

33 楼 mydolors 2009-01-22  

1 public class UserRule {   
2    private static UserRule instance = null;   
3      
4    public static UserRule getInstance() {   
5        if (instance == null) {   
6            instance = new UserRule();   
7        }   
8        return instance;   
9    }  
10      
11   public User AddUser(String userName) {  
12        // add a new user operations  
13   }  
14 } 


这么写存在安全隐患，在一定的情况下会抛出异常。
例如：
前提：大家调用 UserRule.getInstance() 方法获得UserRule的实例。
1.假设UserRule第一次加载，当2个线程 a , b同时调用getInstance()方法初始instance的时候.
线程a执行到6行，在构造函数执行之前，使实例成为非 null,线程a停止。就是这里.
这时线程b 抢占线程，执行到第5行的时候，条件为假，返回insatcne,一个构造完整但部分初始化了的 insatcne对象。 那么客户端就拿到一个还没有完全实例化的对象. 结果可想而之了。

不过我想这种情况发生的概率应该极低吧？

32 楼 czqyr 2009-01-22  

它不是单例模式已经知道了
但我对线程安全不太懂。。。
有什么推荐的文章看一看吗？

31 楼 czqyr 2009-01-22  

哦！
灵牌。。。

30 楼 fjlyxx 2009-01-22  

czqyr 写道

这样不是单例吗？那单例应该是什么样子呢？

严格意义上的单例可以通过端口监听去实现,对于一个JVM的单例可以不用,LZ的并不是单例,直接NEW就可以了.在多线程下线程的安全先要剥离你的共享资源,哪条线程拿到操作令牌就有权对这个资源进行操作.所以单例的安全可以通过令牌去实现.不要把原本就线程不安全的对象作为共享资源.

29 楼 czqyr 2009-01-22  

啊啊，对哦对哦，想起来了，呵呵