生产者消费者 - ExecutorService和ArrayBlockingQueue(producer consumer - ExecutorService & ArrayBlockingQueue)

 我想通过使用ExecutorService和ArrayBlockingQueue来了解我对生产者消费者设计的理解是否正确。 我知道有不同的方法来实现这个设计，但我想，最后，它取决于问题本身。 
 
 我不得不面对的问题是：我有一个生产者从大文件中读取（6GB）; 它逐行读取并将每一行转换为一个对象。 它将对象放在ArrayBlockingQueue中。 
 
 消费者（少数）从ArrayBlockingQueue中获取对象并将其持久保存到数据库中。 
 
 现在，显然生产者比消费者快得多; 将每一行转换为对象需要几分之一秒，但对于消费者来说需要更长的时间。 
 
 所以...如果我希望通过这样做来加速这个过程：我创建了两个分类为'ProducerThread'和'ConsumerThread'的共享ArrayBlockingQueue。 在2之间协调的线程如下所示： 
 
@Override
public void run()
{
    try{

        ArrayBlockingQueue<Ticket> queue = new ArrayBlockingQueue<Ticket>(40);
        ExecutorService threadPool = Executors.newFixedThreadPool(8);

        threadPool.execute(new SaleConsumerThread("NEW YORK", queue)); 
        threadPool.execute(new SaleConsumerThread("PARIS", queue));
        threadPool.execute(new SaleConsumerThread("TEL AVIV", queue));
        threadPool.execute(new SaleConsumerThread("HONG KONG", queue));
        threadPool.execute(new SaleConsumerThread("LONDON", queue));
        threadPool.execute(new SaleConsumerThread("BERLIN", queue));
        threadPool.execute(new SaleConsumerThread("AMSTERDAM", queue));

        Future producerStatus = threadPool.submit(new SaleProducerThread(progressBar, file, queue)); 
        producerStatus.get(); 
        threadPool.shutdown();   

    }catch(Exception exp)
    {
        exp.printStackTrace();
    }
}
 
 我的问题是： 
 
 
 
 上面的设计是否会同时使用每个线程？ 我的电脑是两个2.4GHz四核。 
 
 
 我不确定Future和.get（）的用途是什么？ 
 
 
 顺便说一句，结果是快速的（考虑第一个版本是连续的，需要3小时），现在需要约40分钟（但可能还有改进的余地）。 
 
 谢谢你的指针 

I wish to know if my understanding of the producer consumer design is correct by using the ExecutorService & ArrayBlockingQueue. I understand there are different ways to implement this design but I guess, at the end, it depends on the problem itself.
 
The problem I had to confront is this: I have a ONE producer who reads from a big file (6GB); it reads line by line and converts every line to an object. It places the object in an ArrayBlockingQueue.
 
The consumers (few) take the object from the ArrayBlockingQueue and persist this to the database. 
 
Now, obviously the producer is much faster than the consumer; it takes fractions of seconds to convert each line to an object but for the consumers it takes longer time.
 
So...if I wish to speedup this process by doing this: I created 2 classed 'ProducerThread' and 'ConsumerThread' they share the ArrayBlockingQueue. The Thread that coordinate between the 2 looks like this:
 
@Override
public void run()
{
    try{

        ArrayBlockingQueue<Ticket> queue = new ArrayBlockingQueue<Ticket>(40);
        ExecutorService threadPool = Executors.newFixedThreadPool(8);

        threadPool.execute(new SaleConsumerThread("NEW YORK", queue)); 
        threadPool.execute(new SaleConsumerThread("PARIS", queue));
        threadPool.execute(new SaleConsumerThread("TEL AVIV", queue));
        threadPool.execute(new SaleConsumerThread("HONG KONG", queue));
        threadPool.execute(new SaleConsumerThread("LONDON", queue));
        threadPool.execute(new SaleConsumerThread("BERLIN", queue));
        threadPool.execute(new SaleConsumerThread("AMSTERDAM", queue));

        Future producerStatus = threadPool.submit(new SaleProducerThread(progressBar, file, queue)); 
        producerStatus.get(); 
        threadPool.shutdown();   

    }catch(Exception exp)
    {
        exp.printStackTrace();
    }
}
 
My questions are:
 
 
 
Would the design above actually use each thread concurrently? My computer is Two 2.4GHz Quad-Core. 
 
 
I'm not sure what does the Future and the .get() are for?
 
 
The result, by the way, are fast (consider the first version was sequential and it took 3hr) now it takes ~40 min (but maybe there're room for improvement).
 
Thanks for any pointer

原文：https://stackoverflow.com/questions/10392855