设计模式有哪几种
单例模式中如何实现并发的懒汉模式
1. 最简单的实现
首先,能够想到的最简单的实现是,把类的构造函数写成private的,从而保证别的类不能实例化此类,然后在类中提供一个静态的实例并能够返回给使用者。这样,使用者就可以通过这个引用使用到这个类的实例了。
public class SingletonClass {
private static final SingletonClass instance = new SingletonClass ();
public static SingletonClass getInstance() {
return instance;
}
private SingletonClass() {
}
}
如上例,外部使用者如果需要使用SingletonClass的实例,只能通过getInstance()方法,并且它的构造方法是private的,这样就保证了只能有一个对象存在。
2. 性能优化——lazy loaded
上面的代码虽然简单,但是有一个问题——无论这个类是否被使用,都会创建一个instance对象。如果这个创建过程很耗时,比如需要连接10000次数据库(夸张了…:-)),并且这个类还并不一定会被使用,那么这个创建过程就是无用的。怎么办呢?
为了解决这个问题,我们想到了新的解决方案:
public class SingletonClass {
private static SingletonClass instance = null;
public static SingletonClass getInstance() {
if(instance == null) {
instance = new SingletonClass();
}
return instance;
}
private SingletonClass() {
}
}
代码的变化有两处——首先,把instance初始化为null,直到第一次使用的时候通过判断是否为null来创建对象。因为创建过程不在声明处,所以那个final 的修饰必须去掉。
我们来想象一下这个过程。要使用SingletonClass,调用getInstance()方法。第一次的时候发现instance是null,然后就新建一个对象,返回出去;第二次再使用的时候,因为这个instance是static的,
所以已经不是null了,因此不会再创建对象,直接将其返回。
这个过程就成为lazy loaded,也就是迟加载——直到使用的时候才进行加载。
3. 同步
上面的代码很清楚,也很简单。然而就像那句名言:“80%的错误都是由20%代码优化引起的”。单线程下,这段代码没有什么问题,可是如果是多线程,麻烦就来了。我们来分析一下:
线程A希望使用SingletonClass,调用getInstance()方法。因为是第一次调用,A就发现instance是null的,于是它开始创建实例,就在这个时候,CPU发生
时间片切换,线程B开始执行,它要使用SingletonClass,调用getInstance()方法,同样检测到instance是null——注意,这是在A检测完之后切换的,也就是说A并没有来得及创建对象——因此B开始创建。B创建完成后,切换到A 继续执行,因为它已经检测完了,所以A不会再检测一遍,它会直接创建对象。这样,线程A和B各自拥有一个SingletonClass的对象——单例失败!
解决的方法也很简单,那就是加锁:
public class SingletonClass {
private static SingletonClass instance = null;
public synchronized static SingletonClass getInstance() {
if(instance == null) {
instance = new SingletonClass();
}
return instance;
}
private SingletonClass() {
}
}
是要getInstance()加上同步锁,一个线程必须等待另外一个线程创建完成后才能使用这个方法,这就保证了单例的唯一性。
4. 又是性能
上面的代码又是很清楚很简单的,然而,简单的东西往往不够理想。这段代码毫无疑问存在性能的问题——synchronized修饰的同步块可是要比一般的代码段慢上几倍的!如果存在很多次getInstance()的调用,那性能问题就不得不考虑了!
让我们来分析一下,究竟是整个方法都必须加锁,还是仅仅其中某一句加锁就足
够了?我们为什么要加锁呢?分析一下出现lazy loaded的那种情形的原因。原因就是检测null的操作和创建对象的操作分离了。如果这两个操作能够原子地进行,那么单例就已经保证了。于是,我们开始修改代码:
public class SingletonClass {
private static SingletonClass instance = null;
public static SingletonClass getInstance() {
synchronized(SingletonClass.class) {
if(instance == null) {
instance = new SingletonClass();
}
}
return instance;
}
private SingletonClass() {
}
}
首先去掉getInstance()的同步操作,然后把同步锁加载if语句上。但是这样的修改起不到任何作用:因为每次调用getInstance()的时候必然要同步,性能问题还是存在。如果……如果我们事先判断一下是不是为null再去同步呢?
public class SingletonClass {
private static SingletonClass instance = null;
public static SingletonClass getInstance() {
if(instance == null) {
synchronized(SingletonClass.class) {
if(instance == null) {
instance = new SingletonClass();
}
}
}
return instance;
}
private SingletonClass() {
}
}
还有问题吗?首先判断instance是不是为null,如果为null,加锁初始化;如果不为null,直接返回instance。
这就是double-checked locking设计实现单例模式。到此为止,一切都很完美。我们用一种很聪明的方式实现了单例模式
责任链
问题A:实行一个过滤功能,过滤一段文字
首先获取用户输入的一段文字:String msg = "大家好:),<script>,敏感,被就业,网络授课没感觉,因为看不见大家伙儿";
那么我们写一个  filterMethod(){};  使用最简单的replace方法替换文中的敏感词
问题B:如果想用面向对象的方法去实现呢?
创建一个类MsgProcessor专门用来处理用户输入的文字,该类用一个属性message(用户输入文字),生成set/get方法,
(为什么要通过set/get方法去访问属性,而不直接访问该属性???为了保护该属性,不让用户直接访问修改,如果是你的存折,你可以在set/get方法中加入权限判断,避免让用户直接访问操作;如果让该属性只能够看,不能够修改,则直接删除set方法即可)
一个方法process()(处理文字)    每次只需要将
单例模式的几种实现方式MsgProcessor mp = new MsgProcessor();
mp.setMsg(msg);    mp.process();
问题C:如果我们有多个过滤器,那么如何设计会更加方便以后继续添加??首先我们写一个接口Filter,它有一个doFilter方法,
public interface Filter {
String doFilter(String str);  }
制作接口相当于给所有开发人员制定了规范,然后我们写的每一个过滤器类都要实现该接口,由于有多个过滤器类,所以我们建立一个过滤器类的集合类FilterChain,它需要实现Filter接口,同时要拥有过滤器集合变量public class FilterChain implements Filter {
用集合的好处当有新的过滤器或者过滤器集合类要添加进来,会更加方便List<Filter> filters = new ArrayList<Filter>();
public FilterChain addFilter(Filter f) {
//能够将子类生成的对象赋值给父类,但是不能将父类生成的对象赋值给子类//并且能够将实现接口的类的对象赋值给父类接口,同上一样
this.filters.add(f);
return this;//返回this,也就是返回FilterChain 本身对象}
public String doFilter(String str) {
String r = str;
for(Filter f: filters) {
r = f.doFilter(r);
}  //逐个调用过滤器的dofilter方法
return r;
}
那么单个的过滤器例如HTMLFilter,只需要执行自己的操作
public class HTMLFilter implements Filter {
@Override
public String doFilter(String str) {
//process the html tag <>
String r = place('<', '[')
.replace('>', ']');
return r;
} }
通常我们不希望这样添加
Filter[] filters = {new HTMLFilter(), new SesitiveFilter(), new FaceFilter()};
因为这样会使得每次只要添加新的过滤器,都要修改这个类,所以我们直接使用集合。
那么在main函数中,由于addFilter返回的this,所以可以连写
FilterChain fc = new FilterChain();
fc.addFilter(new HTMLFilter())
.addFilter(new SesitiveFilter())
.addFilter(new FaceFilter()) ;
问题D:如何继续优化该段代码呢?我们希望msgProcess的process方法执行何功能?
也就是需要在MsgProcessor类中加入成员变量FilterChain fc;  public String process() {
return fc.doFilter(msg);
}
那么要想用MsgProcessor类的对象调用process方法,就必须要在MsgProcessor类中生成fc的set/get方法;
String result = mp.process();

版权声明:本站内容均来自互联网,仅供演示用,请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198,我们将在24小时内删除。