public class LinkedList<E> 
  extends AbstractSequentialList<E> 
  implements List<E>, Deque<E>, Cloneable, java.io.Serializable 
{ 
  ........ 
  private static class Entry<E> { 
E element; 
Entry<E> next; 
Entry<E> previous; 
Entry(E element, Entry<E> next, Entry<E> previous) { 
  this.element = element; 
  this.next = next; 
  this.previous = previous; 
} 
  } 
  private Entry<E> addBefore(E e, Entry<E> entry) { 
Entry<E> newEntry = new Entry<E>(e, entry, entry.previous); 
newEntry.previous.next = newEntry; 
newEntry.next.previous = newEntry; 
size++; 
modCount++; 
return newEntry; 
  } 
  ........ 
} 

/** 
 * 需要啟動多個線程把接口數(shù)據(jù)分批導入目標，要求 
 * 每次執(zhí)行的時候必須保證前一次任務已結(jié)束,處理這個需求的方式有很多種，其實質(zhì)即 
 * 線程間同步問題，正好這兩天我也在關(guān)注線程同步相關(guān)的東東，jdk提供了不少的線程 
 * 同步工具類，CountDownLatch：一個同步輔助類，在完成一組正在其他線程中執(zhí)行的 
 * 操作之前，它允許一個或多個線程一直等待。 
 * 用給定的計數(shù) 初始化 CountDownLatch。由于調(diào)用了 countDown() 方法，所以在當前計數(shù)到達零之前， 
 * await 方法會一直受阻塞。之后，會釋放所有等待的線程，await 的所有后續(xù)調(diào)用都將立即返回。 
 * 這種現(xiàn)象只出現(xiàn)一次——計數(shù)無法被重置（這點很重要哦）。如果需要重置計數(shù)，請考慮使用 CyclicBarrier。 
 * 下面是一個簡單的例子來模擬該需求，當然可能因為為了模擬場景，會有一些不合理的地方，這里主要闡述 
 * CountDownLatch同步,關(guān)于CountDownLatch的源碼將在后面來分析，其主要涉及AbstractQueuedSynchronizer 
 * 這個類，他的類容相對比較復雜 
 * **/ 
 
import java.util.ArrayList; 
import java.util.List; 
import java.util.Random; 
import java.util.concurrent.CountDownLatch; 
 
public class Driver { 
 static List<Integer> strList = null; 
 int k = 0; 
 static { 
 //模擬數(shù)據(jù) 
 strList = new ArrayList<Integer>(); 
 for (int i = 0; i < 50; i++) { 
  strList.add(i); 
 } 
 } 
 
 public static void main(String args[]) { 
 boolean isEnd = true; 
 //為了驗證正確性，只執(zhí)行20次 
 int count=0; 
 Driver d = new Driver(); 
 while (isEnd && strList.size() > 0&&count<20) { 
  CountDownLatch startSignal = new CountDownLatch(1); 
  final CountDownLatch doneSignal = new CountDownLatch(5); 
  for (int i = 0; i < 5; ++i) 
  { 
  new Thread(d.new Worker(startSignal, doneSignal,i)).start(); 
  } 
  //計數(shù)減1 子線程Worker可以執(zhí)行 
  startSignal.countDown(); 
  try { 
  new Thread(new Runnable() { 
   Random r = new Random(); 
   @Override 
   public void run() { 
   try { 
    //主線程阻塞 知道所有子線程將doneSignal清零 
    doneSignal.await(); 
   } catch (InterruptedException e) { 
    e.printStackTrace(); 
   } 
   while(strList.size()<=0){ 
    int pos = r.nextInt(1000); 
    strList.clear(); 
    for (int i = pos; i < pos + 50; i++) { 
    strList.add(i); 
    } 
   } 
   } 
  }).start(); 
  isEnd = true; 
  } catch (Exception e) { 
  e.printStackTrace(); 
  } 
  count++; 
 } 
 } 
 
 class Worker implements Runnable { 
 private final CountDownLatch startSignal; 
 private final CountDownLatch doneSignal; 
 private int i; 
 
 Worker(CountDownLatch startSignal, CountDownLatch doneSignal,int i) { 
  this.startSignal = startSignal; 
  this.doneSignal = doneSignal; 
  this.i=i; 
  
 } 
 
 public void run() { 
  try { 
  // 等待主線程執(zhí)行countDown 
  startSignal.await(); 
  doWork(); 
  //計數(shù)減1 
  doneSignal.countDown(); 
  } catch (InterruptedException ex) { 
  } // return; 
 } 
 
 void doWork() { 
  synchronized (strList) { 
  int start=(i)*(50/5); 
  int end=(i+1)*(50/5); 
  for (int i = start; i < end; i++) { 
   System.out.println(strList.get(i) + "---" + "已被刪除"); 
  } 
  } 
 } 
 } 
}