並發編程 01—— ThreadLocal

 

概述

第1部分 定義

第2部分 實例

 

第1部分 定義

　　“毒丸”是指一個放在隊列上的對象，其含義是：“當得到這個對象時，立即停止。”在FIFO 隊列中，“毒丸”對象將確保消費者在關閉之前首先完成隊列中的所有工作，在提交“毒丸”對象之前提交的所有工作都會被處理，而生產者在提交了“毒丸”對象后，將不會在提交任何工作。在下面的程序清單中給出了一個單生產者——單消費者的桌面搜索示例，使用了“毒丸”對象來關閉服務。

 

第2部分 實例

/**
 * 7.17 通過“毒丸”對象來關閉服務
 * @ClassName: IndexingService 
 * @author xingle
 * @date 2014-11-12 下午1:58:06
 */
public class IndexingService {
    private static final int CAPACITY = 1000;
    private static final File POISON = new File("");
    private final IndexerThread consumer = new IndexerThread();
    private final CrawlerThread producer = new CrawlerThread();
    private final BlockingQueue<File> queue;
    //private final FileFilter fileFilter;
    private final File root;

    public IndexingService(File root) {
        this.root = root;
        this.queue = new LinkedBlockingQueue<File>(CAPACITY);
        
    }

    private boolean alreadyIndexed(File f) {
        return false;
    }

    //生產者
    class CrawlerThread extends Thread {
        public void run() {
            try {
                crawl(root);
            } catch (InterruptedException e) { /* fall through */
            } finally {
                while (true) {
                    try {
                        System.out.println("放入“毒丸”");
                        queue.put(POISON);
                        break;
                    } catch (InterruptedException e1) { /* retry */
                    }
                }
            }
        }

        private void crawl(File root) throws InterruptedException {
            File[] entries = root.listFiles();
            if (entries != null) {
                for (File entry : entries) {
                    if (entry.isDirectory())
                        crawl(entry);
                    else if (!alreadyIndexed(entry)){
                        System.out.println("放入生產者隊列文件："+entry.getName()+" 來自線程："+Thread.currentThread().getName());
                        queue.put(entry);
                    }
                }
            }
        }
    }

    //消費者
    class IndexerThread extends Thread {
        public void run() {
            try {
                while (true) {
                    File file = queue.take();
                    if (file == POISON){
                        System.out.println("遇到“毒丸”，終止");
                        break;
                    }
                        
                    else
                        indexFile(file);
                }
            } catch (InterruptedException consumed) {
            }
        }

        public void indexFile(File file) {
            System.out.println("消費者取出文件："+file.getName()+" 來自線程："+Thread.currentThread().getName());
            /* ... */
        };
    }

    public void start() {
        producer.start();
        consumer.start();
    }

    public void stop() {
        producer.interrupt();
    }

    public void awaitTermination() throws InterruptedException {
        consumer.join();
    }

}

 

測試代碼：

/**
 * 7.17 測試主程序（ 通過“毒丸”對象來關閉服務）
 * @ClassName: IndexingService_Main
 * @author xingle
 * @date 2014-11-12 下午2:25:36
 */
public class IndexingService_Main {
    public static void main(String[] args) {
        File file = new File("D:\\test1/");
        IndexingService c = new IndexingService(file);
        c.start();
        try {
            TimeUnit.MICROSECONDS.sleep(100);// 停止ＸＸ時間，顯示出消費速度慢於生產速度　
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        c.stop();
    }
}

 

單次執行結果：

 

只有在生產者和消費者的數量都已知的情況下，才可以使用”毒丸“對象。

在 IndexingService中采用的解決方案可以擴展到多個生產者：只需每個生產者都想隊列放入一個”毒丸“對象，並且消費者僅當在接收到N個生產者的”毒丸“對象時才停止。這種方法也可以擴展到多個消費者的情況，只需生產者將N個”毒丸“對象放入隊列。然而，當生產者和消費者的數量較大時，這種方法將變的難以使用。只有在無界隊列中，”毒丸“對象才能可靠地工作。