javafifo

『壹』 java中的集合有幾種

集合類是放在java.util.*；這個包里。集合類存放的都是對象的引用，而非對象本身，為了說起來方便些，我們稱集合中的對象就是指集合中對象的引用（reference)。引用的概念大家不會忘了吧，在前邊我們講數據類型時講的。
集合類型主要有3種：set(集）、list(列表）、map(映射)和Queue（隊列）。//隊列為jdk5中的加上的

(1) Set

集（set）是最簡單的一種集合，它的對象不按特定方式排序，只是簡單的把對象加入集合中，就像往口袋裡放東西。對集中成員的訪問和操作是通過集中對象的引用進行的，所以集中不能有重復對象。我們知道數學上的集合也是Set這個，集合裡面一定是沒有重復的元素的。

（2）List

列表（List）的主要特徵是其對象以線性方式存儲，沒有特定順序，只有一個開頭和一個結尾，當然，它與根本沒有順序的Set是不同的。它是鏈表嘛，一條鏈肯定有順序這個順序就不一定了。

（3）Map

映射（Map），這個在java里不是地圖的意思，其實地圖也是映射哈。它裡面的東西是鍵－值對（key-value）出現的，鍵值對是什麼呢？舉個例子，比如我們查字典，用部首查字法。目錄那個字就是鍵，這個字的解釋就是值。鍵和值成對出現。這樣說可以理解吧。這也是很常用的數據結構哦。

（4）Queue

在jdk5.0以前，通常的實現方式是使用java.util.List集合來模仿Queue。Queue的概念通過把對象添加（稱為enqueuing的操作）到List的尾部（即Queue的後部）並通過從List的頭部（即Queue的前部）提取對象而從 List中移除（稱為dequeuing的操作）來模擬。你需要執行先進先出的動作時可以直接使用Queue介面就可以了。

這4個東西，有時候功能還不太完善，需要有些子類繼承它的特性。Set的子介面有TreeSet,SortedSet，List的有ArrayList等，Map里有HashMap,HashTable等，Queue裡面有BlockingQueue等。我們來看看例子吧：

實踐： Set舉例

import java.util.*;

public class SetExample {

public static void main(String[] args) {

Set set = new HashSet(); //HashSet是Set的子介面

set.add("one");

set.add("second");

set.add("3rd");

set.add(new Integer(4));

set.add(new Float( 5.0F ));

set.add("second");

set.add(new Integer(4));

System.out.println(set);

}}

List舉例：

import java.util.*;

public class ListExample {

public static void main(String[] args) {

List list = new ArrayList();

list.add("one");

list.add("second");

list.add("3rd");

list.add(new Integer(4));

list.add(new Float( 5.0F ));

list.add("second");

list.add(new Integer(4));

System.out.println(list);

}}

Map舉例

import java.util.Map;

import java.util.HashMap;

import java.util.Iterator;

import java.io.FileReader;

public class MapExample {

public static void main(String[] args) throws java.io.FileNotFoundException {

Map word_count_map = new HashMap();

FileReader reader = new FileReader(args[0]);

Iterator words = new WordStreamIterator(reader);

while ( words.hasNext() ) {

String word = (String) words.next();

String word_lowercase = word.toLowerCase();

Integer frequency = (Integer)word_count_map.get(word_lowercase);

if ( frequency == null ) {

frequency = new Integer(1);

} else {

int value = frequency.intValue();

frequency = new Integer(value + 1);}

word_count_map.put(word_lowercase, frequency);

}

System.out.println(word_count_map);

}}

Queue舉例：

import java.io.IOException;

import java.io.PrintStream;

import java.util.LinkedList;

import java.util.Queue;

public class QueueTester {

public Queue<String> q; //發現了一個奇怪的語法，這個尖括弧是泛型聲明

public QueueTester() {q = new LinkedList<String>();}

public void testFIFO(PrintStream out) throws IOException {

q.add("First");

q.add("Second");

q.add("Third");

Object o;

while ((o = q.poll()) != null) {

out.println(o);}}

public static void main(String[] args) {

QueueTester tester = new QueueTester();

try { tester.testFIFO(System.out);

} catch (IOException e) {

e.printStackTrace(); } }}

『貳』 如何用java實現fifo頁面置換演算法

[fifo.rar] - 操作系統中內存頁面的先進先出的替換演算法fifo
[先進先出頁面演算法程序.rar] - 分別實現最佳置換演算法(optimal)、先進先出(fifo)頁面置換演算法和最近最久未使用（LRU）置換演算法，並給出各演算法缺頁次數和缺頁率。
[0022.rar] - 模擬分頁式虛擬存儲管理中硬體的地址轉換和缺頁中斷，以及選擇頁面調度演算法處理缺頁中斷
[Change.rar] - 用java實現操作系統的頁面置換 其中包括 最佳置換演算法(Optimal)、先進先出演算法（First-in, First-out） 、最近最久不用的頁面置換演算法（LeastRecently Used Replacement）三種演算法的實現
[M_Management.rar] - 操作系統中內存管理頁面置換演算法的模擬程序，採用的是LRU置換演算法
[detail_of_44b0x_TCPIP.rar] - TCPIP 程序包載入到44b0x 的ADS1.2工程文件的說明書。說名了載入過程的細節和如何處理演示程序和代碼。演示代碼已經上傳，大家可以搜索
[.rar] - java操作系統頁面置換演算法： （1）進先出的演算法（fifo） （2）最近最少使用的演算法（LRU） （3）最佳淘汰演算法(OPT) （4）最少訪問頁面演算法(LFU) （註：由本人改成改進型Clock演算法） （5）最近最不經常使用演算法(NUR)

『叄』 java如何實現進程間的通信

傳統的進程間通信的方式有大致如下幾種：

(1) 管道(PIPE)
(2) 命名管道(FIFO)
(3) 信號量(Semphore)
(4) 消息隊列(MessageQueue)
(5) 共享內存(SharedMemory)
(6) Socket

Java如何支持進程間通信。我們把Java進程理解為JVM進程。很明顯，傳統的這些大部分技術是無法被我們的應用程序利用了（這些進程間通信都是靠系統調用來實現的）。但是Java也有很多方法可以進行進程間通信的。
除了上面提到的Socket之外，當然首選的IPC可以使用Rmi，或者Corba也可以。另外Java nio的MappedByteBuffer也可以通過內存映射文件來實現進程間通信(共享內存)。

『肆』 java 中 阻塞隊列 非阻塞隊列 和普通隊列的區別是什麼

阻塞隊列與普通隊列的區別在於，當隊列是空的時，從隊列中獲取元素的操作將會被阻塞，或者當隊列是滿時，往隊列里添加元素的操作會被阻塞。試圖從空的阻塞隊列中獲取元素的線程將會被阻塞，直到其他的線程往空的隊列插入新的元素。同樣，試圖往已滿的阻塞隊列中添加新元素的線程同樣也會被阻塞，直到其他的線程使隊列重新變得空閑起來，如從隊列中移除一個或者多個元素，或者完全清空隊列.
1.ArrayDeque, （數組雙端隊列）
2.PriorityQueue, （優先順序隊列）
3.ConcurrentLinkedQueue, （基於鏈表的並發隊列）
4.DelayQueue, （延期阻塞隊列）（阻塞隊列實現了BlockingQueue介面）
5.ArrayBlockingQueue, （基於數組的並發阻塞隊列）
6.LinkedBlockingQueue, （基於鏈表的FIFO阻塞隊列）
7.LinkedBlockingDeque, （基於鏈表的FIFO雙端阻塞隊列）
8.PriorityBlockingQueue, （帶優先順序的無界阻塞隊列）
9.SynchronousQueue （並發同步阻塞隊列）
阻塞隊列和生產者-消費者模式
阻塞隊列（Blocking queue）提供了可阻塞的put和take方法，它們與可定時的offer和poll是等價的。如果Queue已經滿了，put方法會被阻塞直到有空間可用；如果Queue是空的，那麼take方法會被阻塞，直到有元素可用。Queue的長度可以有限，也可以無限；無限的Queue永遠不會充滿，所以它的put方法永遠不會阻塞。
阻塞隊列支持生產者-消費者設計模式。一個生產者-消費者設計分離了「生產產品」和「消費產品」。該模式不會發現一個工作便立即處理，而是把工作置於一個任務（「to do」）清單中，以備後期處理。生產者-消費者模式簡化了開發，因為它解除了生產者和消費者之間相互依賴的代碼。生產者和消費者以不同的或者變化的速度生產和消費數據，生產者-消費者模式將這些活動解耦，因而簡化了工作負荷的管理。
生產者-消費者設計是圍繞阻塞隊列展開的，生產者把數據放入隊列，並使數據可用，當消費者為適當的行為做准備時會從隊列中獲取數據。生產者不需要知道消費者的省份或者數量，甚至根本沒有消費者—它們只負責把數據放入隊列。類似地，消費者也不需要知道生產者是誰，以及是誰給它們安排的工作。BlockingQueue可以使用任意數量的生產者和消費者，從而簡化了生產者-消費者設計的實現。最常見的生產者-消費者設計是將線程池與工作隊列相結合。
阻塞隊列簡化了消費者的編碼，因為take會保持阻塞直到可用數據出現。如果生產者不能足夠快地產生工作，讓消費者忙碌起來，那麼消費者只能一直等待，直到有工作可做。同時，put方法的阻塞特性也大大地簡化了生產者的編碼；如果使用一個有界隊列，那麼當隊列充滿的時候，生產者就會阻塞，暫不能生成更多的工作，從而給消費者時間來趕進進度。
有界隊列是強大的資源管理工具，用來建立可靠的應用程序：它們遏制那些可以產生過多工作量、具有威脅的活動，從而讓你的程序在面對超負荷工作時更加健壯。
雖然生產者-消費者模式可以把生產者和消費者的代碼相互解耦合，但是它們的行為還是間接地通過共享隊列耦合在一起了
類庫中包含一些BlockingQueue的實現，其中LinkedBlockingQueue和ArrayBlockingQueue是FIFO隊列，與 LinkedList和ArrayList相似，但是卻擁有比同步List更好的並發性能。PriorityBlockingQueue是一個按優先順序順序排序的隊列，當你不希望按照FIFO的屬性處理元素時，這個PriorityBolckingQueue是非常有用的。正如其他排序的容器一樣，PriorityBlockingQueue可以比較元素本身的自然順序（如果它們實現了Comparable），也可以使用一個 Comparator進行排序。
最後一個BlockingQueue的實現是SynchronousQueue，它根本上不是一個真正的隊列，因為它不會為隊列元素維護任何存儲空間。不過，它維護一個排隊的線程清單，這些線程等待把元素加入（enqueue）隊列或者移出（dequeue）隊列。因為SynchronousQueue沒有存儲能力，所以除非另一個線程已經准備好參與移交工作，否則put和take會一直阻止。SynchronousQueue這類隊列只有在消費者充足的時候比較合適，它們總能為下一個任務作好准備。
非阻塞演算法
基於鎖的演算法會帶來一些活躍度失敗的風險。如果線程在持有鎖的時候因為阻塞I/O，頁面錯誤，或其他原因發生延遲，很可能所有的線程都不能前進了。
一個線程的失敗或掛起不應該影響其他線程的失敗或掛起，這樣的演算法成為非阻塞（nonblocking）演算法；如果演算法的每一個步驟中都有一些線程能夠繼續執行，那麼這樣的演算法稱為鎖自由（lock-free）演算法。在線程間使用CAS進行協調，這樣的演算法如果能構建正確的話，它既是非阻塞的，又是鎖自由的。非競爭的CAS總是能夠成功，如果多個線程以一個CAS競爭，總會有一個勝出並前進。非阻塞演算法堆死鎖和優先順序倒置有「免疫性」（但它們可能會出現飢餓和活鎖，因為它們允許重進入）。
非阻塞演算法通過使用低層次的並發原語，比如比較交換，取代了鎖。原子變數類向用戶提供了這些底層級原語，也能夠當做「更佳的volatile變數」使用，同時提供了整數類和對象引用的原子化更新操作

『伍』 請分別給出三種不同的頁面置換演算法,並簡要說明他們的優缺點

[fifo.rar]
-
操作系統中內存頁面的先進先出的替換演算法fifo
[先進先出頁面演算法程序.rar]
-
分別實現最佳置換演算法(optimal)、先進先出(fifo)頁面置換演算法和最近最久未使用（LRU）置換演算法，並給出各演算法缺頁次數和缺頁率。
[0022.rar]
-
模擬分頁式虛擬存儲管理中硬體的地址轉換和缺頁中斷，以及選擇頁面調度演算法處理缺頁中斷
[Change.rar]
-
用java實現操作系統的頁面置換
其中包括
最佳置換演算法(Optimal)、先進先出演算法（First-in,
First-out）
、最近最久不用的頁面置換演算法（LeastRecently
Used
Replacement）三種演算法的實現
[M_Management.rar]
-
操作系統中內存管理頁面置換演算法的模擬程序，採用的是LRU置換演算法
[detail_of_44b0x_TCPIP.rar]
-
TCPIP
程序包載入到44b0x
的ADS1.2工程文件的說明書。說名了載入過程的細節和如何處理演示程序和代碼。演示代碼已經上傳，大家可以搜索
[.rar]
-
java操作系統頁面置換演算法：
（1）進先出的演算法（fifo）
（2）最近最少使用的演算法（LRU）
（3）最佳淘汰演算法(OPT)
（4）最少訪問頁面演算法(LFU)
（註：由本人改成改進型Clock演算法）
（5）最近最不經常使用演算法(NUR)

『陸』 用java語言實現LRU演算法和FIFO演算法。急急急！！！！！！！

您好，網路貼吧專家團很高興能夠回答您的問題。您的採納是我們前進的動力。
public class LRU {

private int theArray[];
private int back; //定義隊尾
private int currentSize; //隊列中存放元素個數
private int maxSize=5; //隊列中能存放元素的個數

public LRU(){
theArray=new int[maxSize];
back=0;
currentSize=0;
}
public void queue(int a[]){
for(int i=0;i<a.length;i++){
enQueue(a[i]);
}
}

public void enQueue(int x){ //入隊
beUsed(x); //先判斷是否已存在該頁號，若存在，刪除
if(currentSize<maxSize){
theArray[back]=x;
back++;
currentSize++;
}else if(currentSize==maxSize){ //滿了
for(int i=0;i<maxSize-1;i++){
theArray[i]=theArray[i+1];
}
theArray[maxSize-1]=x;
}
for(int i=0;i<currentSize;i++){
System.out.print(theArray[i]);
}
System.out.println();
}
public void beUsed(int x){ //判斷是否已存在該頁號,若存在，刪除已有的
for(int i=0;i<currentSize;i++){
if(theArray[i]==x){
for(int j=i;j<currentSize-1;j++){
theArray[j]=theArray[j+1];
}
currentSize--;
back--;
}
}
}
public static void main(String[] args) {
LRU lru=new LRU();
int a[]={4,7,0,7,1,0,1,2,1,2,6};
lru.queue(a);
}

}

『柒』 java 用什麼實現 FIFO隊列

java使用數據結構來實現FIFO先進先出的隊列，實例如下：

/*
*Tochangethistemplate,chooseTools|Templates
*andopenthetemplateintheeditor.
*/
packagelinkedlisttest;

importjava.util.ArrayList;
importjava.util.Deque;
importjava.util.LinkedList;
importjava.util.List;

/**
*
*@authorVicky.H
*@[email protected]
*/
publicclassFIFOTest{

/**
*@
*/
publicstaticvoidmain(String[]args){
FIFO<A>fifo=newFIFOImpl<A>(5);
for(inti=0;i<20;i++){
Aa=newA("A:"+i);
Ahead=fifo.addLastSafe(a);
System.out.println(i+"	head:"+head+"	size:"+fifo.size());
}

System.out.println("---------------");

System.out.println("彈出數據");
List<A>polls=fifo.setMaxSize(3);
for(Aa:polls){
System.out.println("	head:"+a);
}

System.out.println("剩餘數據");
for(Aa:fifo){
System.out.println("	head:"+a);
}
System.out.println(fifo.size());
}
}

interfaceFIFO<T>extendsList<T>,Deque<T>,Cloneable,java.io.Serializable{

/**
*向最後添加一個新的，如果長度超過允許的最大值，則彈出一個*
*/
TaddLastSafe(TaddLast);

/**
*彈出head，如果Size=0返回null。而不同於pop拋出異常
*@return
*/
TpollSafe();

/**
*獲得最大保存
*
*@return
*/
intgetMaxSize();

/**
*設置最大存儲范圍
*
*@return返回的是，因為改變了隊列大小，導致彈出的head
*/
List<T>setMaxSize(intmaxSize);

}

classFIFOImpl<T>extendsLinkedList<T>implementsFIFO<T>{

privateintmaxSize=Integer.MAX_VALUE;
privatefinalObjectsynObj=newObject();

publicFIFOImpl(){
super();
}

publicFIFOImpl(intmaxSize){
super();
this.maxSize=maxSize;
}

@Override
publicTaddLastSafe(TaddLast){
synchronized(synObj){
Thead=null;
while(size()>=maxSize){
head=poll();
}
addLast(addLast);
returnhead;
}
}

@Override
publicTpollSafe(){
synchronized(synObj){
returnpoll();
}
}

@Override
publicList<T>setMaxSize(intmaxSize){
List<T>list=null;
if(maxSize<this.maxSize){
list=newArrayList<T>();
synchronized(synObj){
while(size()>maxSize){
list.add(poll());
}
}
}
this.maxSize=maxSize;
returnlist;
}

@Override
publicintgetMaxSize(){
returnthis.maxSize;
}
}

classA{

privateStringname;

publicA(){
}

publicA(Stringname){
this.name=name;
}

publicStringgetName(){
returnname;
}

publicvoidsetName(Stringname){
this.name=name;
}

@Override
publicStringtoString(){
return"A{"+"name="+name+'}';
}
}

『捌』 如何使用queue

Queue介面與List、Set同一級別，都是繼承了Collection介面。LinkedList實現了Queue接 口。Queue介面窄化了對LinkedList的方法的訪問許可權（即在方法中的參數類型如果是Queue時，就完全只能訪問Queue介面所定義的方法 了，而不能直接訪問 LinkedList的非Queue的方法），以使得只有恰當的方法才可以使用。BlockingQueue 繼承了Queue介面。

隊列是一種數據結構．它有兩個基本操作：在隊列尾部加人一個元素，和從隊列頭部移除一個元素就是說，隊列以一種先進先出的方式管理數據，如果你試圖向一個 已經滿了的阻塞隊列中添加一個元素或者是從一個空的阻塞隊列中移除一個元索，將導致線程阻塞．在多線程進行合作時，阻塞隊列是很有用的工具。工作者線程可 以定期地把中間結果存到阻塞隊列中而其他工作者線線程把中間結果取出並在將來修改它們。隊列會自動平衡負載。如果第一個線程集運行得比第二個慢，則第二個 線程集在等待結果時就會阻塞。如果第一個線程集運行得快，那麼它將等待第二個線程集趕上來。下表顯示了jdk1.5中的阻塞隊列的操作：

add 增加一個元索 如果隊列已滿，則拋出一個IIIegaISlabEepeplian異常
remove 移除並返回隊列頭部的元素 如果隊列為空，則拋出一個NoSuchElementException異常
element 返回隊列頭部的元素 如果隊列為空，則拋出一個NoSuchElementException異常
offer 添加一個元素並返回true 如果隊列已滿，則返回false
poll 移除並返問隊列頭部的元素 如果隊列為空，則返回null
peek 返回隊列頭部的元素 如果隊列為空，則返回null
put 添加一個元素 如果隊列滿，則阻塞
take 移除並返回隊列頭部的元素 如果隊列為空，則阻塞

remove、element、offer 、poll、peek 其實是屬於Queue介面。

阻塞隊列的操作可以根據它們的響應方式分為以下三類：aad、removee和element操作在你試圖為一個已滿的隊列增加元素或從空隊列取得元素時 拋出異常。當然，在多線程程序中，隊列在任何時間都可能變成滿的或空的，所以你可能想使用offer、poll、peek方法。這些方法在無法完成任務時 只是給出一個出錯示而不會拋出異常。

注意：poll和peek方法出錯進返回null。因此，向隊列中插入null值是不合法的。

還有帶超時的offer和poll方法變種，例如，下面的調用：
boolean success = q.offer(x,100,TimeUnit.MILLISECONDS);
嘗試在100毫秒內向隊列尾部插入一個元素。如果成功，立即返回true；否則，當到達超時進，返回false。同樣地，調用：
Object head = q.poll(100, TimeUnit.MILLISECONDS);
如果在100毫秒內成功地移除了隊列頭元素，則立即返回頭元素；否則在到達超時時，返回null。

最後，我們有阻塞操作put和take。put方法在隊列滿時阻塞，take方法在隊列空時阻塞。

java.ulil.concurrent包提供了阻塞隊列的4個變種。默認情況下，LinkedBlockingQueue的容量是沒有上限的（說的不準確，在不指定時容量為Integer.MAX_VALUE，不要然的話在put時怎麼會受阻呢），但是也可以選擇指定其最大容量，它是基於鏈表的隊列，此隊列按 FIFO（先進先出）排序元素。

ArrayBlockingQueue在構造時需要指定容量， 並可以選擇是否需要公平性，如果公平參數被設置true，等待時間最長的線程會優先得到處理（其實就是通過將ReentrantLock設置為true來 達到這種公平性的：即等待時間最長的線程會先操作）。通常，公平性會使你在性能上付出代價，只有在的確非常需要的時候再使用它。它是基於數組的阻塞循環隊 列，此隊列按 FIFO（先進先出）原則對元素進行排序。

PriorityBlockingQueue是一個帶優先順序的 隊列，而不是先進先出隊列。元素按優先順序順序被移除，該隊列也沒有上限（看了一下源碼，PriorityBlockingQueue是對 PriorityQueue的再次包裝，是基於堆數據結構的，而PriorityQueue是沒有容量限制的，與ArrayList一樣，所以在優先阻塞 隊列上put時是不會受阻的。雖然此隊列邏輯上是無界的，但是由於資源被耗盡，所以試圖執行添加操作可能會導致 OutOfMemoryError），但是如果隊列為空，那麼取元素的操作take就會阻塞，所以它的檢索操作take是受阻的。另外，往入該隊列中的元 素要具有比較能力。

最後，DelayQueue（基於PriorityQueue來實現的）是一個存放Delayed 元素的無界阻塞隊列，只有在延遲期滿時才能從中提取元素。該隊列的頭部是延遲期滿後保存時間最長的 Delayed 元素。如果延遲都還沒有期滿，則隊列沒有頭部，並且poll將返回null。當一個元素的 getDelay(TimeUnit.NANOSECONDS) 方法返回一個小於或等於零的值時，則出現期滿，poll就以移除這個元素了。此隊列不允許使用 null 元素。 下面是延遲介面：
Java代碼
public
interface
Delayed
extends
Comparable<Delayed>
{

long
getDelay(TimeUnit
unit);

}

放入DelayQueue的元素還將要實現compareTo方法，DelayQueue使用這個來為元素排序。

下面的實例展示了如何使用阻塞隊列來控制線程集。程序在一個目錄及它的所有子目錄下搜索所有文件，列印出包含指定關鍵字的文件列表。從下面實例可以看出，使用阻塞隊列兩個顯著的好處就是：多線程操作共同的隊列時不需要額外的同步，另外就是隊列會自動平衡負載，即那邊（生產與消費兩邊）處理快了就會被阻塞掉，從而減少兩邊的處理速度差距。下面是具體實現：
Java代碼
public
class
BlockingQueueTest
{

public
static
void
main(String[]
args)
{

Scanner
in
=
new
Scanner(System.in);

System.out.print("Enter
base
directory
(e.g.
/usr/local/jdk5.0/src):
");

String
directory
=
in.nextLine();

System.out.print("Enter
keyword
(e.g.
volatile):
");

String
keyword
=
in.nextLine();

final
int
FILE_QUEUE_SIZE
=
10;//
阻塞隊列大小

final
int
SEARCH_THREADS
=
100;//
關鍵字搜索線程個數

//
基於ArrayBlockingQueue的阻塞隊列

BlockingQueue<File>
queue
=
new
ArrayBlockingQueue<File>(

FILE_QUEUE_SIZE);

//只啟動一個線程來搜索目錄

FileEnumerationTask
enumerator
=
new
FileEnumerationTask(queue,

new
File(directory));

new
Thread(enumerator).start();

//啟動100個線程用來在文件中搜索指定的關鍵字

for
(int
i
=
1;
i
<=
SEARCH_THREADS;
i++)

new
Thread(new
SearchTask(queue,
keyword)).start();

}

}

class
FileEnumerationTask
implements
Runnable
{

//啞元文件對象，放在阻塞隊列最後，用來標示文件已被遍歷完

public
static
File
DUMMY
=
new
File("");

private
BlockingQueue<File>
queue;

private
File
startingDirectory;

public
FileEnumerationTask(BlockingQueue<File>
queue,
File
startingDirectory)
{

this.queue
=
queue;

this.startingDirectory
=
startingDirectory;

}

public
void
run()
{

try
{

enumerate(startingDirectory);

queue.put(DUMMY);//執行到這里說明指定的目錄下文件已被遍歷完

}
catch
(InterruptedException
e)
{

}

}

//
將指定目錄下的所有文件以File對象的形式放入阻塞隊列中

public
void
enumerate(File
directory)
throws
InterruptedException
{

File[]
files
=
directory.listFiles();

for
(File
file
:
files)
{

if
(file.isDirectory())

enumerate(file);

else

//將元素放入隊尾，如果隊列滿，則阻塞

queue.put(file);

}

}

}

class
SearchTask
implements
Runnable
{

private
BlockingQueue<File>
queue;

private
String
keyword;

public
SearchTask(BlockingQueue<File>
queue,
String
keyword)
{

this.queue
=
queue;

this.keyword
=
keyword;

}

public
void
run()
{

try
{

boolean
done
=
false;

while
(!done)
{

//取出隊首元素，如果隊列為空，則阻塞

File
file
=
queue.take();

if
(file
==
FileEnumerationTask.DUMMY)
{

//取出來後重新放入，好讓其他線程讀到它時也很快的結束

queue.put(file);

done
=
true;

}
else

search(file);

}

}
catch
(IOException
e)
{

e.printStackTrace();

}
catch
(InterruptedException
e)
{

}

}

public
void
search(File
file)
throws
IOException
{

Scanner
in
=
new
Scanner(new
FileInputStream(file));

int
lineNumber
=
0;

while
(in.hasNextLine())
{

lineNumber++;

String
line
=
in.nextLine();

if
(line.contains(keyword))

System.out.printf("%s:%d:%s%n",
file.getPath(),
lineNumber,

line);

}

in.close();

}

}