南村土人

准则：采用参与者与参与者目标的视点

jokermanager — Sun, 06 Jul 2008 11:20:43 +0800

作者: jokermanager 链接：http://agio.javaeye.com/blog/212009 发表时间: 2008年07月06日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

1、一组用例实例，每个实例是系统所执行的一系列活动，以此产生对特定参与者具有价值的可观察结果。

2、关注系统的用户或参与者来编写需求，询问其目标和典型情况。

3、关注理解参与者所考虑的有价值结果。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

准则：编写黑盒用例

jokermanager — Sun, 06 Jul 2008 11:12:09 +0800

作者: jokermanager 链接：http://agio.javaeye.com/blog/212007 发表时间: 2008年07月06日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

1、黑盒用例是最常用的和推荐使用的类型。它不对系统内部的工作、构件或设计进行描述。

2、黑盒用例以职责来描述系统，这是面向对象思想中普遍统一的隐喻主题-软件元素具有职责，并与其他具有职责的元素进行协作。

3、黑盒用例定义系统职责，可以规定系统必须做什么，而不必关心系统如何去做。

4、分析与设计的区别，就在于”什么“和”如何“。

5、在分析中应避免进行”如何“的决策，而是规定系统的外部行为。

6、在设计过程中，创建满足该规则说明的解决方案。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

准则：编写简洁的用例

jokermanager — Sun, 06 Jul 2008 11:07:28 +0800

作者: jokermanager 链接：http://agio.javaeye.com/blog/212004 发表时间: 2008年07月06日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

1、应该编写简洁的用例，删除“噪音”词汇。

2、即使是一些细微之处也会积累为繁琐。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

准则：以无用户界面约束的本质风格编写用例

jokermanager — Sun, 06 Jul 2008 11:03:56 +0800

作者: jokermanager 链接：http://agio.javaeye.com/blog/212002 发表时间: 2008年07月06日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

1、通过对目标层次的研究，系统分析员会发现与实现机制无关的目标。

2、这种对根源目标的发现过程能够扩展视野，以促成新的和改进的解决方案。

3、摈除用户界面于思考范围之外，集中于意图。

4、以本质风格编写用例，摈除用户界面并且关注参与者的意图。

5、具体风格的用例编写方式，不适合于早期的需求分析工作，应该避免。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

知识丰富的设计

jokermanager — Sun, 06 Jul 2008 10:05:30 +0800

作者: jokermanager 链接：http://agio.javaeye.com/blog/211979 发表时间: 2008年07月06日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

1、业务活动与规则对于一个领域来说与其涉及的实体同样重要。

2、领域也会包含各种类别的概念。对知识的消化要能够产生出反映这种理解的模型。

3、超越实体与值之上的变化可能会对知识消化产生剧烈的影响，因为业务规则之间可能存在不一致。

4、领域专家通过与软件专家的密切合作，进行知识消化，才使得规则明晰化。

5、提炼隐藏概念，将业务规则可以放到一个领域对象中。

6、任何业务专家都不可能阅读代码来检对规则。

7、一个非业务人员的技术人员，要将需求文档与代码联系起来是很困难的。

8、可以通过改善设计来更好的捕获知识。

9、规则的实现应该是独立的。

10、一个领域模型和其相应的设计能够被用来保护和分享知识。

11、航运中的超额预定是一个重要的业务规则，并不仅仅是一个含糊的计算问题。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

Replace Array with Object 以对象取代数组

jokermanager — Sat, 05 Jul 2008 20:26:54 +0800

作者: jokermanager 链接：http://agio.javaeye.com/blog/211922 发表时间: 2008年07月05日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

1、如果一个数组中的各个元素代表了不同的东西，考虑用Object来代替数组。

2、数组应该只用于容纳一组相似对象。

3、如果一个数组容纳了不同对象，会给array用户带来麻烦。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

常见的软件隐喻

jokermanager — Sat, 05 Jul 2008 20:14:40 +0800

作者: jokermanager 链接：http://agio.javaeye.com/blog/211918 发表时间: 2008年07月05日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

1、重要的研发成果常常产自类比。通过把你不太理解的东西和你较为理解、十分类似的东西进行比较，你可以对这些不太理解的东西产生更深刻的理解。这种使用隐喻的方法叫做“建模”。

2、软件隐喻不会告诉你到哪里去找答案，仅告诉你该如何找到答案。隐喻的作用更像启示，而不是算法。

3、“增量的”、“迭代的”、“自适应的”、“演进的”，以增量的方式进行设计、编码和测试，是目前已知的最强有力的软件开发概念。

4、进行增量开发时，我们先做出软件系统一个尽可能简单、但能运行的版本。它仅仅需要构成一个足够强壮的骨架，支撑起来未来将要开发的真实系统。

5、增量开发的优势在于未做过的承诺。

6、软件开发中的几个事项：问题定义、架构设计、详细设计、构建、优化、评审、详查。

7、使用现成的东西，自己编写能买到的代码是没有意义的。

8、适当的多层次的规划对于建造建筑和构建软件都是有好处的。

9、精心计划，并不意味着事无巨细的计划或者过度的计划。

10、一个规划得当的项目能够提升你“在后期改变细节（设计）”的能力。

11、不同的软件项目能够从不同的开发方法中获益。

12、软件开发中，通常你只需要用灵活的、轻量级的方法，但有时你就必须得用严格的、重量级的开发方法，以达到所需的安全性目标或其他目标。

13、对于超大型的软件项目，就需要比一般规模项目有更高级别的规划设计。

14、技术并不是规矩，它只是分析工具。好的工匠知道完成某项工作需要什么工具，也知道如何正确使用，程序员也该这样。不存在任何一个能适用于所有工作的工具，因地制宜地选择工具是称为能有效编程的程序员的关键。

15、隐喻只是一种启发方法而不是算法，他们之间并不排斥。应当使用对你最有益处的某种隐喻组合。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

知识消化

jokermanager — Sat, 05 Jul 2008 19:52:46 +0800

作者: jokermanager 链接：http://agio.javaeye.com/blog/211916 发表时间: 2008年07月05日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

1、高效的建模人员就是知识的消化器。

2、知识消化并不是一个孤立的行动，它由开发团队与领域专家共同合作，由开发人员领导。

3、老式的瀑布方法中，业务专家与分析人员会谈，分析人员提取摘要，进行抽象后将结果转达给程序员，由程序员进行编码。这种方法并不成功，因为没有反馈机制。

4、优秀的程序员会自然地开始进行抽象来开发一个模型。

5、在团队成员一起讨论模型的过程中，他们之间的交互也会发生变化。模型的不断精化使得开发人员不断学习他们所需要的重要业务原理。领域专家通过提炼他们认为必须的知识来精化他们的理解。

6、程序员、分析人员、领域专家都介入其中，模型变得组织有序并且抽象合理，能够反应业务的深层知识。抽象出来的都是真正的业务原则。

7、模型永远都不是完美的，他们会不断发展。模型对于领域来说必须是实用的。他们必须十分精确，使得应用程序易于实现和理解。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

有效建模的因素

jokermanager — Sat, 05 Jul 2008 19:43:45 +0800

作者: jokermanager 链接：http://agio.javaeye.com/blog/211914 发表时间: 2008年07月05日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

1. 模型与实现相互绑定。未经加工的原型建立了早期必需的联系，在随后的迭代中始终对它进行维护和完善。

2. 基于模型生成了一种语言。随着项目的进行，我们中的每个人都可以自如地使用来自模型的术语，将它们组织成与模型结构一致的句子，不需翻译，也不会引起歧义。

3. 开发了一个包含丰富知识的模型。对象都具有行为和一些强制性的规则。模型并不仅仅是一个数据方案，它是解决一个复杂问题必不可缺的。它捕获了各种类型的知识。

4. 提炼模型。在模型变得更加完善的过程中，一些重要的概念被加入其中。同样重要的是，如果概念被证明没有用处或并不重要，则应该丢弃。如果一个不必要的概念与一个需要的概念结合在一起，新的模型将会分离出有用的概念而丢弃另一个。

5. 头脑风暴与实验。与草图和头脑风暴方式相结合的语言使得我们的讨论成为模型实验室，在这里，会对数以百计的实验变种进行尝试和鉴定。当团队审查场景时，口头的表述提供了一种测试模型的快速方式，因为耳朵能够快速地发现表述中的明确性、简易性和不协调的部分。

头脑风暴和大量实验的创造力使得我们能创建一个知识丰富的模型并进行提炼，基于模型的语言以及实现的反馈循环中的约束则提供了支持。这种知识消化(knowledge crunching)过程将团队的知识转化为有价值的模型。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

用例的编写

jokermanager — Sat, 05 Jul 2008 19:36:16 +0800

作者: jokermanager 链接：http://agio.javaeye.com/blog/211913 发表时间: 2008年07月05日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

1、用例、UML图等保证不会是完美的。它们可能会遗漏关键信息或者包含错误陈述。解决方案并不是以瀑布的态度试图近乎完美地记录规格说明并且在开始阶段就完成此项工作。

2、编写用例的折中方案是介于瀑布和即兴编程之间的迭代和进化式开发。

3、以增量式进化、验证用例和其他模型，并且通过及早的编程和测试加以明确。

4、如果在第一次开发迭代之前，小组就视图详尽地编写所有或大部分用例时，此时要意识到你已经走入歧途了。反之，则恭喜你！

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

JDK5新特性--java.util.concurrent ExecutorCompletionSe

jokermanager — Fri, 04 Jul 2008 10:25:56 +0800

作者: jokermanager 链接：http://agio.javaeye.com/blog/211385 发表时间: 2008年07月04日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

考虑以下场景：浏览网页时，浏览器了5个线程下载网页中的图片文件，由于图片大小、网站访问速度等诸多因素的影响，完成图片下载的时间就会有很大的不同。如果先下载完成的图片就会被先显示到界面上，反之，后下载的图片就后显示。

Java的并发库的CompletionService 可以满足这种场景要求。该接口有两个重要方法：submit()和take()。submit用于提交一个runnable或者callable，一般会提交给一个线程池处理；而take就是取出已经执行完毕runnable或者callable实例的Future对象，如果没有满足要求的，就等待了。 CompletionService还有一个对应的方法poll，该方法与take类似，只是不会等待，如果没有满足要求，就返回null对象。


package 

concurrent;




import 

java.util.concurrent.Callable;


import 

java.util.concurrent.CompletionService;


import 

java.util.concurrent.ExecutionException;


import 

java.util.concurrent.ExecutorCompletionService;


import 

java.util.concurrent.ExecutorService;


import 

java.util.concurrent.Executors;


import 

java.util.concurrent.Future;




public class 

TestCompletionService 
{


  
public static 

void 

main
(
String
[] 
args
) 
throws 

InterruptedException,


      
ExecutionException 
{


    
ExecutorService exec = Executors.newFixedThreadPool
(
10
)
;


    
CompletionService serv = 


      
new 

ExecutorCompletionService
(
exec
)
;




    
for 

(
int 

index = 
0
; index < 
5
; index++
) {


      
final 

int 

NO = index;


      
Callable downImg = 
new 

Callable
() {


        
public 

String call
() 
throws 

Exception 
{


          
Thread.sleep
((
long

) (
Math.random
() 
* 
10000
))
;


          
return 

"Downloaded Image " 
+ NO;


        
}


      
}
;


      
serv.submit
(
downImg
)
;


    
}




    
Thread.sleep
(
1000 
* 
2
)
;


    
System.out.println
(
"Show web content"
)
;


    
for 

(
int 

index = 
0
; index < 
5
; index++
) {


      
Future task = serv.take
()
;


      
String img = task.get
()
;


      
System.out.println
(
img
)
;


    
}


    
System.out.println
(
"End"
)
;


    
// 关闭线程池


    
exec.shutdown
()
;


  
}


}

运行结果:
Show web content
Downloaded Image 1
Downloaded Image 2
Downloaded Image 4
Downloaded Image 0
Downloaded Image 3
End

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

JDK5新特性--java.util.concurrent CyclicBarrier(3)

jokermanager — Thu, 03 Jul 2008 15:13:33 +0800

作者: jokermanager 链接：http://agio.javaeye.com/blog/211097 发表时间: 2008年07月03日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

在实际应用中，有时候需要多个线程同时工作以完成同一件事情，而且在完成过程中，往往会等待其他线程都完成某一阶段后再执行，等所有线程都到达某一个阶段后再统一执行。

比如有几个旅行团需要途经深圳、广州、韶关、长沙最后到达武汉。旅行团中有自驾游的，有徒步的，有乘坐旅游大巴的；这些旅行团同时出发，并且每到一个目的地，都要等待其他旅行团到达此地后再同时出发，直到都到达终点站武汉。

这时候CyclicBarrier 就可以派上用场。CyclicBarrier最重要的属性就是参与者个数，另外最要方法是await()。当所有线程都调用了await()后，就表示这些线程都可以继续执行，否则就会等待。


package 

concurrent;


import 

java.text.SimpleDateFormat;


import 

java.util.Date;


import 

java.util.concurrent.BrokenBarrierException;


import 

java.util.concurrent.CyclicBarrier;


import 

java.util.concurrent.ExecutorService;


import 

java.util.concurrent.Executors;


public class 

TestCyclicBarrier 
{


  
// 徒步需要的时间: Shenzhen, Guangzhou, Shaoguan, Changsha, Wuhan


  
private static 

int

[] 
timeWalk = 
{ 
5
, 
8
, 
15
, 
15
, 
10 
}
;


  
// 自驾游


  
private static 

int

[] 
timeSelf = 
{ 
1
, 
3
, 
4
, 
4
, 
5 
}
;


  
// 旅游大巴


  
private static 

int

[] 
timeBus = 
{ 
2
, 
4
, 
6
, 
6
, 
7 
}
;


  


  
static 

String now
() {


    
SimpleDateFormat sdf = 
new 

SimpleDateFormat
(
"HH:mm:ss"
)
;


    
return 

sdf.format
(
new 

Date
()) 
+ 
": "
;


  
}




  
static class 

Tour 
implements 

Runnable 
{


    
private 

int

[] 
times;


    
private 

CyclicBarrier barrier;


    
private 

String tourName;


    
public 

Tour
(
CyclicBarrier barrier, String tourName, 
int

[] 
times
) {


      
this

.times = times;


      
this

.tourName = tourName;


      
this

.barrier = barrier;


    
}


    
public 

void 

run
() {


      
try 

{


        
Thread.sleep
(
times
[
0
] 
* 
1000
)
;


        
System.out.println
(
now
() 
+ tourName + 
" Reached Shenzhen"
)
;


        
barrier.await
()
;


        
Thread.sleep
(
times
[
1
] 
* 
1000
)
;


        
System.out.println
(
now
() 
+ tourName + 
" Reached Guangzhou"
)
;


        
barrier.await
()
;


        
Thread.sleep
(
times
[
2
] 
* 
1000
)
;


        
System.out.println
(
now
() 
+ tourName + 
" Reached Shaoguan"
)
;


        
barrier.await
()
;


        
Thread.sleep
(
times
[
3
] 
* 
1000
)
;


        
System.out.println
(
now
() 
+ tourName + 
" Reached Changsha"
)
;


        
barrier.await
()
;


        
Thread.sleep
(
times
[
4
] 
* 
1000
)
;


        
System.out.println
(
now
() 
+ tourName + 
" Reached Wuhan"
)
;


        
barrier.await
()
;


      
} 
catch 

(
InterruptedException e
) {


      
} 
catch 

(
BrokenBarrierException e
) {


      
}


    
}


  
}




  
public static 

void 

main
(
String
[] 
args
) {


    
// 三个旅行团


    
CyclicBarrier barrier = 
new 

CyclicBarrier
(
3
)
;


    
ExecutorService exec = Executors.newFixedThreadPool
(
3
)
;


    
exec.submit
(
new 

Tour
(
barrier, 
"WalkTour"
, timeWalk
))
;


    
exec.submit
(
new 

Tour
(
barrier, 
"SelfTour"
, timeSelf
))
;


    
exec.submit
(
new 

Tour
(
barrier, 
"BusTour"
, timeBus
))
;


    
exec.shutdown
()
;


  
}


}

运行结果：
00:02:25: SelfTour Reached Shenzhen
00:02:25: BusTour Reached Shenzhen
00:02:27: WalkTour Reached Shenzhen
00:02:30: SelfTour Reached Guangzhou
00:02:31: BusTour Reached Guangzhou
00:02:35: WalkTour Reached Guangzhou
00:02:39: SelfTour Reached Shaoguan
00:02:41: BusTour Reached Shaoguan

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

java基础－－Java 5.0多线程编程（3）

jokermanager — Thu, 03 Jul 2008 14:35:54 +0800

作者: jokermanager 链接：http://agio.javaeye.com/blog/211076 发表时间: 2008年07月03日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

Lock 接口

ReentrantLock 是 Lock 的具体类， Lock 提供了以下一些方法：

lock(): 请求锁定，如果锁已被别的线程锁定，调用此方法的线程被阻断进入等待状态。
tryLock() ：如果锁没被别的线程锁定，进入锁定状态，并返回 true 。若锁已被锁定，返回 false ，不进入等待状态。此方法还可带时间参数，如果锁在方法执行时已被锁定，线程将继续等待规定的时间，若还不行才返回 false 。
unlock() ：取消锁定，需要注意的是 Lock 不会自动取消，编程时必须手动解锁。

代码：

// 生成一个锁

Lock lock = new ReentrantLock();

public void accessProtectedResource() {

lock.lock(); // 取得锁定

try {

// 对共享资源进行操作

} finally {

// 一定记着把锁取消掉，锁本身是不会自动解锁的

lock.unlock();

}

ReadWriteLock 接口

为了提高效率有些共享资源允许同时进行多个读的操作，但只允许一个写的操作，比如一个文件，只要其内容不变可以让多个线程同时读，不必做排他的锁定，排他的锁定只有在写的时候需要，以保证别的线程不会看到数据不完整的文件。 ReadWriteLock 可满足这种需要。 ReadWriteLock 内置两个 Lock ，一个是读的 Lock ，一个是写的 Lock 。多个线程可同时得到读的 Lock ，但只有一个线程能得到写的 Lock ，而且写的 Lock 被锁定后，任何线程都不能得到 Lock 。 ReadWriteLock 提供的方法有：

readLock(): 返回一个读的 lock
writeLock(): 返回一个写的 lock, 此 lock 是排他的。

ReadWriteLock 的例子：

public class FileOperator{

// 初始化一个 ReadWriteLock

ReadWriteLock lock = new ReentrantReadWriteLock();

public String read() {

// 得到 readLock 并锁定

Lock readLock = lock.readLock();

readLock.lock();

try {

// 做读的工作

return "Read something";

} finally {

readLock.unlock();

}

public void write(String content) {

// 得到 writeLock 并锁定

Lock writeLock = lock.writeLock();

writeLock.lock();

try {

// 做读的工作

} finally {

writeLock.unlock();

}

需要注意的是 ReadWriteLock 提供了一个高效的锁定机理，但最终程序的运行效率是和程序的设计息息相关的，比如说如果读的线程和写的线程同时在等待，要考虑是先发放读的 lock 还是先发放写的 lock 。如果写发生的频率不高，而且快，可以考虑先给写的 lock 。还要考虑的问题是如果一个写正在等待读完成，此时一个新的读进来，是否要给这个新的读发锁，如果发了，可能导致写的线程等很久。等等此类问题在编程时都要给予充分的考虑。

Condition 接口：

有时候线程取得 lock 后需要在一定条件下才能做某些工作，比如说经典的 Producer 和 Consumer 问题， Consumer 必须在篮子里有苹果的时候才能吃苹果，否则它必须暂时放弃对篮子的锁定，等到 Producer 往篮子里放了苹果后再去拿来吃。而 Producer 必须等到篮子空了才能往里放苹果，否则它也需要暂时解锁等 Consumer 把苹果吃了才能往篮子里放苹果。在 Java 5.0 以前，这种功能是由 Object 类的 wait(), notify() 和 notifyAll() 等方法实现的，在 5.0 里面，这些功能集中到了 Condition 这个接口来实现， Condition 提供以下方法：

await() ：使调用此方法的线程放弃锁定，进入睡眠直到被打断或被唤醒。
signal(): 唤醒一个等待的线程
signalAll() ：唤醒所有等待的线程

Condition 的例子：

public class Basket {

Lock lock = new ReentrantLock();

// 产生 Condition 对象

Condition produced = lock.newCondition();

Condition consumed = lock.newCondition();

boolean available = false;

public void produce() throws InterruptedException {

lock.lock();

try {

if(available){

consumed.await(); // 放弃 lock 进入睡眠

}

/* 生产苹果 */

System.out.println("Apple produced.");

available = true;

produced.signal(); // 发信号唤醒等待这个 Condition 的线程

} finally {

lock.unlock();

}

public void consume() throws InterruptedException {

lock.lock();

try {

if(!available){

produced.await();// 放弃 lock 进入睡眠

}

/* 吃苹果 */

System.out.println("Apple consumed.");

available = false;

consumed.signal();// 发信号唤醒等待这个 Condition 的线程

} finally {

lock.unlock();

}

ConditionTester:

public class ConditionTester {

public static void main(String[] args) throws InterruptedException{

final Basket basket = new Basket();

// 定义一个 producer

Runnable producer = new Runnable() {

public void run() {

try {

basket.produce();

} catch (InterruptedException ex) {

ex.printStackTrace();

}

};

// 定义一个 consumer

Runnable consumer = new Runnable() {

public void run() {

try {

basket.consume();

} catch (InterruptedException ex) {

ex.printStackTrace();

}

};

// 各产生 10 个 consumer 和 producer

ExecutorService service = Executors.newCachedThreadPool();

for(int i=0; i < 10; i++)

service.submit(consumer);

Thread.sleep(2000);

for(int i=0; i<10; i++)

service.submit(producer);

service.shutdown();

}

5: Synchronizer：同步装置

Java 5.0 里新加了 4 个协调线程间进程的同步装置，它们分别是 Semaphore, CountDownLatch, CyclicBarrier 和 Exchanger.

Semaphore:

用来管理一个资源池的工具， Semaphore 可以看成是个通行证，线程要想从资源池拿到资源必须先拿到通行证， Semaphore 提供的通行证数量和资源池的大小一致。如果线程暂时拿不到通行证，线程就会被阻断进入等待状态。以下是一个例子：

public class Pool {

ArrayList pool = null;

Semaphore pass = null;

public Pool(int size){

// 初始化资源池

pool = new ArrayList();

for(int i=0; i

pool.add("Resource "+i);

}

//Semaphore 的大小和资源池的大小一致

pass = new Semaphore(size);

}

public String get() throws InterruptedException{

// 获取通行证 , 只有得到通行证后才能得到资源

pass.acquire();

return getResource();

}

public void put(String resource){

// 归还通行证，并归还资源

pass.release();

releaseResource(resource);

}

private synchronized String getResource() {

String result = pool.get(0);

pool.remove(0);

System.out.println("Give out "+result);

return result;

}

private synchronized void releaseResource(String resource) {

System.out.println("return "+resource);

pool.add(resource);

}

SemaphoreTest:

public class SemaphoreTest {

public static void main(String[] args){

final Pool aPool = new Pool(2);

Runnable worker = new Runnable() {

public void run() {

String resource = null;

try {

// 取得 resource

resource = aPool.get();

} catch (InterruptedException ex) {

ex.printStackTrace();

}

// 用 resource 做工作

System.out.println("I worked on "+resource);

// 归还 resource

aPool.put(resource);

}

};

ExecutorService service = Executors.newCachedThreadPool();

for(int i=0; i<20; i++){

service.submit(worker);

}

service.shutdown();

}

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐