Question

我正在研究一个基于Java的程序，它从一个文件中读取并将每一行发送到它自己的处理Runnable中以进行一些单线程计算。我正在使用一个固定的线程池，每个可用的核心一个任务，以并行化这个。文件很大，在提交作业时无法将每个文件加载到内存中。是否有可能让主线程（即提交这些任务）暂停，直到线程池中的线程可用为止？

Answer 1

使用与池大小相同的可用工作线程创建一个简单的线程池。在提交检查可用线程是否存在然后提交其他等待锁定。

此外，您可以使用信号量，它将阻塞，直到acquire（）获得一些值。信号量例外：

Semaphore semaphore = new Semaphore(pool_size);

//critical section
semaphore.acquire();

...

semaphore.release();

简单线程池的示例：

    private List<WorkerThread> workers;
        private LinkedList<WorkerThread> availWorkers = new LinkedList<WorkerThread>();
        private LinkedList<WorkerThread> busyWorkers = new LinkedList<WorkerThread>();

提交方法

   public boolean submit(Runnable runnable) {
            if (runnable == null) {
                return false;
            }

            synchronized (Lock) {

                handoffPending = true;

                // Wait until a worker thread is available
                while ((availWorkers.size() < 1) && !isShutdown) {
                    try {
                        Lock.wait(500);
                    } catch (InterruptedException ignore) {
                    }
                }

                if (!isShutdown) {
                    WorkerThread wt = (WorkerThread)availWorkers.removeFirst();
                    busyWorkers.add(wt);
                    wt.run(runnable);
                } else {
                    // If the thread pool is going down, execute the Runnable
                    // within a new additional worker thread (no thread from the pool).
                    WorkerThread wt = new WorkerThread(this, threadGroup,
                            "WorkerThread-LastJob", prio, isMakeThreadsDaemons(), runnable);
                    busyWorkers.add(wt);
                    workers.add(wt);
                    wt.start();
                }
                Lock.notifyAll();

            }

            return true;
        }

固定线程池：暂停直到线程可用？

1 个答案: