多线程读写文件 java多线程读写文件示例

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import com.google.common.collect.Lists;

public class WriteQueue {
 private static final int MAX_QUEUE_SIZE = 10000;
 private LinkedList<String> queueCache = Lists.newLinkedList();
 private Lock lock = new ReentrantLock();
 private Condition full = lock.newCondition();
 private Condition empty = lock.newCondition();

 private WriteQueue() {
 }

 private static class WriteQueueHolder {
  private final static WriteQueue INSTANCE = new WriteQueue();
 }

 public static WriteQueue getInstance() {
  return WriteQueueHolder.INSTANCE;
 }

 public void add(String line) {
  lock.lock();
  try {
   while (queueCache.size() >= MAX_QUEUE_SIZE) {
    full.await();
   }
   queueCache.addFirst(line);
   empty.signal();
  } catch (InterruptedException e) {
   e.printStackTrace();
  } finally {
   lock.unlock();
  }
 }

 public void add(List<String> lineList) {
  lock.lock();
  try {
   while (queueCache.size() >= MAX_QUEUE_SIZE) {
    full.await();
   }
   queueCache.addAll(lineList);
   empty.signal();
  } catch (InterruptedException e) {
   e.printStackTrace();
  } finally {
   lock.unlock();
  }
 }

 public ArrayList<String> flush() {
  ArrayList<String> temp = null;
  lock.lock();
  try {
   while (queueCache.size() == 0) {
    empty.await();
   }
   temp = Lists.newArrayList();
   temp.addAll(queueCache);
   queueCache.clear();
   full.signal();
  } catch (InterruptedException e) {
   e.printStackTrace();
  } finally {
   lock.unlock();
  }
  return temp;
 }

}