refactor遇到死胡同。 (转)

refactor遇到死胡同。 (转)[@more@]

郁闷， refactor遇到死胡同。

我有一个接口Pool, 如下：
public interface Pool{
 Worker getWorker();
}
用来从池中取得一个Worker对象。Worker的接口是：
public interface Worker{
 public void start(Runnable r);
}
另外有一个接口PoolOwner, 作为一个Pool的拥有者，可以对Pool进行清理，关闭等操作
public interface PoolOwner extends Pool{
 public void close();
 ...
}
现在，一个异步任务处理模块需要使用Pool对象。同时，我不想让这个任务处理模块拥有Pool对象的所有权，因为，多个不同的模块可能要共享一个Pool.
可是，我又需要保证Pool对象在不用时被关掉。依赖finalize当然是不好的了。

所以，这里，我引入了引用计数的机制：
一个Referent接口，代表计数server, 它应当拥有一个Pool的所有权。
public interface Referent{
 public void enref();
 public void deref();
 public Pool get();
}
一个线程安全的实现代码是：
final class ReferentImpl implements Referent{
 public synchronized void enref(){++count;}
 public synchronized void deref(){
 if(--count<=0)pool.close();
 }
 public Pool get(){return pool;}
 private final PoolOwner pool;
 private int count=1;
 private ReferentImpl(final PoolOwner p){this.pool = p;}
 static Referent instance(final PoolOwner p){return ReferentImpl(p);}
}

此外，我们还需要一个代表引用计数客户的借口。
public interface Ref extends Pool{
 public Ref enref();
 public void release();
}
这里，对客户端的考虑是：
1。 绝对不允许一个Ref对象把Referent的计数递减两次。否则，一个客户的失误就又可能影响到其它客户的工作。
enref将生成一个新的客户，而旧的客户仍然只需调用release一次。
我的实现是这样：
首先，做一个null reference.

final class NilReferent implements Referent{
 public void enref(){
 throw new NilRefException();
 }
 public void deref(){}
 public Pool get(){throw new NilRefException();}
 ...//这里，做一个singleton.
}
然后：
final class RefImpl implements Ref{
 public Ref enref(){
 ref.enref();
 return instance(ref);
 }
 public void release(){
 ref.deref();
 ref = NilReferent.instance();
 }
 public Worker get(){
 return ref.get().getWorker();
 }
 protected final void finalize(){ref.deref();}
 private RefImpl (final Referent r){this.ref = r;}
 static Ref instance(Referend r){return new RefImpl(r);}
}

测试的代码如下：
PoolOwner pool = ......;
final Ref r1 = RefImpl.instance(ReferentImpl.instance(pool));
final Ref r2 = r1.enref();
r1.get();
r1.release();//释放r1
r2.get();//这里，r2可以工作
r1.release();//抛出异常，r1已经调用过一次release
r2.get();//r2仍然可以照常工作
r2.release();//这里，计数减到0， pool会被Referent关闭
r2.get();//抛出异常，r2已经release了。

好，到此，一切都很好。但接下来。。。

我还有一个接口Processor
public interface Processor extends Worker{
 public void interrupt();
}
这个Processor提供中断的功能，因此，会要求实现者更复杂的逻辑，而且会有一定的效率上的代价。
有了Processor, 就有ProcessorPool
public interface ProcessorPool{
 public Processor getProcessor();
}
ok, 我也实现了Processor和ProcessorPool. 以及，很自然的ProcessorPoolOwner:
public interface ProcessorPoolOwner extends ProcessorPool{
 public void close();
}

好啦，现在，如果我也要实现以上的引用计数逻辑，怎么办？
有什么好办法可以不用copy&paste呢？感觉象到了死胡同啊！

 

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

转载于:http://blog.itpub.net/10752043/viewspace-991547/