用Executors框架封装一个多任务处理器

用Executors框架封装一个多线程处理器的一个不错的例子。
本例子，通过读取一个文件，然后通过将打印任务放入任务队列，最后通过事先准备好的线程池将任务队列处理。

// Consumer.java
public interface Consumer {
    public boolean consume(Item j);  

    public void finishConsumption();  
}

// ConsumerImpl.java
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;

public class ConsumerImpl implements Consumer {

    // 任务集合
    private BlockingQueue<Item> itemQueue = new LinkedBlockingQueue<Item>();

    // 线程池
    private ExecutorService executorService = Executors.newCachedThreadPool();

    // 任务处理器集合
    private List<ItemProcessor> jobList = new LinkedList<ItemProcessor>();

    // 关闭标志
    private volatile boolean shutdownCalled = false;

    /**
     * 初始 线程池
     * 
     * @param poolSize
     */
    public ConsumerImpl(int poolSize) {
        for (int i = 0; i < poolSize; i++) {
            // 同一个itemQueue
            ItemProcessor jobThread = new ItemProcessor(itemQueue);
            jobList.add(jobThread);
            // 将任务提交到线程池中
            executorService.submit(jobThread);
        }
    }

    @Override
    public boolean consume(Item j) {
        if (!shutdownCalled) {
            try {
                itemQueue.put(j);
            } catch (InterruptedException ie) {
                Thread.currentThread().interrupt();
                return false;
            }
            return true;
        } else {
            return false;
        }
    }

    @Override
    public void finishConsumption() {
        for (ItemProcessor j : jobList) {
            j.cancelExecution();
        }

        executorService.shutdown();
    }
}

// Item.java
public interface Item {
    public void process();
}

// ItemProcessor.java
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * 任务处理器
 * 
 * @author TreeNode
 * 
 */
public class ItemProcessor implements Runnable {

    // 任务队列
    private BlockingQueue<Item> jobQueue;

    // 是否处理标志
    private volatile boolean keepProcessing;

    public ItemProcessor(BlockingQueue<Item> queue) {
        jobQueue = queue;
        keepProcessing = true;
    }

    @Override
    public void run() {
        while (keepProcessing || !jobQueue.isEmpty()) {
            try {
                // 将任务从任务队列移除
                Item j = jobQueue.poll(10, TimeUnit.SECONDS);
                // 并处理
                if (j != null) {
                    j.process();
                }
            } catch (InterruptedException ie) {
                Thread.currentThread().interrupt();
                return;
            }
        }
    }

    public void cancelExecution() {
        this.keepProcessing = false;
    }
}

// Test.java
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class Test {
    public static void main(String[] args) throws IOException {

        String path = "E:\\runtime-EclipseApplication\\c6713_gpio_test\\c6713_gpio_test.json";

        Consumer consumer = new ConsumerImpl(10);

        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(new File(
                path))));

        String line = "";

        while ((line = br.readLine()) != null) {
            // System.out.println("Producer producing: " + line);
            consumer.consume(new PrintJob(line));
        }

        consumer.finishConsumption();
    }
}

class PrintJob implements Item {
    private String line;

    public PrintJob(String s) {
        line = s;
    }

    public void process() {
        System.out.println(Thread.currentThread().getName() + " consuming :" + line);
    }
}