在實際應用中，有時候需要多個線程同時工作以完成同一件事情，而且在完成過程中，往往會等待其他線程都完成某一階段后再執行，等所有線程都到達某一個階段后再統一執行。

比如有幾個旅行團需要途經深圳、廣州、韶關、長沙最后到達武漢。旅行團中有自駕游的，有徒步的，有乘坐旅游大巴的；這些旅行團同時出發，并且每到一個目的地，都要等待其他旅行團到達此地后再同時出發，直到都到達終點站武漢。

這時候CyclicBarrier就可以派上用場。CyclicBarrier最重要的屬性就是參與者個數，另外最要方法是await()。當所有線程都調用了await()后，就表示這些線程都可以繼續執行，否則就會等待。

運行結果：
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

并發庫中的BlockingQueue是一個比較好玩的類，顧名思義，就是阻塞隊列。該類主要提供了兩個方法put()和take()，前者將一個對象放到隊列中，如果隊列已經滿了，就等待直到有空閑節點；后者從head取一個對象，如果沒有對象，就等待直到有可取的對象。

下 面的例子比較簡單，一個讀線程，用于將要處理的文件對象添加到阻塞隊列中，另外四個寫線程用于取出文件對象，為了模擬寫操作耗時長的特點，特讓線程睡眠一 段隨機長度的時間。另外，該Demo也使用到了線程池和原子整型（AtomicInteger），AtomicInteger可以在并發情況下達到原子化 更新，避免使用了synchronized，而且性能非常高。由于阻塞隊列的put和take操作會阻塞，為了使線程退出，特在隊列中添加了一個“標 識”，算法中也叫“哨兵”，當發現這個哨兵后，寫線程就退出。

當然線程池也要顯式退出了。

package concurrent;
import java.io.File;
import java.io.FileFilter;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;

public class TestBlockingQueue {
  static long randomTime() {
    return (long) (Math.random() * 1000);
  }

  public static void main(String[] args) {
    // 能容納100個文件
    final BlockingQueue<File> queue = new LinkedBlockingQueue<File>(100);
    // 線程池
    final ExecutorService exec = Executors.newFixedThreadPool(5);
    final File root = new File("F:\\JavaLib");
    // 完成標志
    final File exitFile = new File("");
    // 讀個數
    final AtomicInteger rc = new AtomicInteger();
    // 寫個數
    final AtomicInteger wc = new AtomicInteger();
    // 讀線程
    Runnable read = new Runnable() {
      public void run() {
        scanFile(root);
        scanFile(exitFile);
      }

      public void scanFile(File file) {
        if (file.isDirectory()) {
          File[] files = file.listFiles(new FileFilter() {
            public boolean accept(File pathname) {
              return pathname.isDirectory()
                  || pathname.getPath().endsWith(".java");
            }
          });
          for (File one : files)
            scanFile(one);
        } else {
          try {
            int index = rc.incrementAndGet();
            System.out.println("Read0: " + index + " "
                + file.getPath());
            queue.put(file);
          } catch (InterruptedException e) {
          }
        }
      }
    };
    exec.submit(read);
    // 四個寫線程
    for (int index = 0; index < 4; index++) {
      // write thread
      final int NO = index;
      Runnable write = new Runnable() {
        String threadName = "Write" + NO;
        public void run() {
          while (true) {
            try {
              Thread.sleep(randomTime());
              int index = wc.incrementAndGet();
              File file = queue.take();
              // 隊列已經無對象
              if (file == exitFile) {
                // 再次添加"標志"，以讓其他線程正常退出
                queue.put(exitFile);
                break;
              }
              System.out.println(threadName + ": " + index + " "
                  + file.getPath());
            } catch (InterruptedException e) {
            }
          }
        }
      };
      exec.submit(write);
    }
    exec.shutdown();
  }
}