Question

我用N个线程初始化了一个exectuor服务。在N个线程完成之后，我想等待一段时间，然后使用N个线程的新实例重用执行程序。我该怎么做？

以下是我正在使用的示例代码失败：

       int NumberOfThreads=Integer.parseInt(PropertyHandler.getProperty("numberOfThreads"));

       ExecutorService executor = Executors.newFixedThreadPool(NumberOfThreads);
       log.info("Executor class has been initialized");
       while (true) {

        jobStack = MrMestri.buildJobs();
        log.info("Creating a job stack of the search urls");
        if (jobStack.isEmpty()) 
        {
           Thread.sleep(10000);
        } 
        else {
           int jobToken = 0;
           while (jobStack.size() > 0) {
           jobToken++;
           MrRunnable worker = new MrRunnable(jobStack.pop());
           executor.execute(worker);
           if (jobToken% Integer.parseInt(PropertyHandler.getProperty("totalTrends")) == 0)       {
           log.info("All jobs for the clock cycle complete , waiting for next clock cycle to start. Number of jobs completed " + jobToken);
           executor.shutdown();
           Thread.sleep(milliseconds);

}

现在我正在使用执行器关闭，没有执行器来执行我的线程。我的线程实现了runnable。

任何快速反应都会有很大帮助。谢谢。

Answer 1

不要关闭执行程序 - 重新使用它。生成一组Callable任务而不是Runnable并使用：

executor.invokeAll

它将执行所有任务并在所有任务完成后立即返回。如果MrRunnable不是你的班级或出于任何原因必须实现Runnable，你只需将其转换为Callable，如：

new Callable<Void>()
    {
        @Override
        public Void call() throws Exception {
            worker.run();
            return null;
        }
    };

Answer 2

问题在于放在while循环内的下面一行。

jobStack = MrMestri.buildJobs();

在这种情况下，下面的条件将始终返回false，因为如果要处理下N个任务，jobStack永远不会为空

jobStack.isEmpty()

如果条件满足处理下N个任务，则在内部while循环和break内部循环中移动此条件。

示例代码：

import java.util.Stack;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Executor {

    /**
     * @param args
     * @throws InterruptedException
     */
    public static void main(String[] args) throws InterruptedException {
        int NumberOfThreads = Integer.parseInt("10");

        ExecutorService executor = Executors.newFixedThreadPool(NumberOfThreads);
        while (true) {

            Stack<Job> jobStack = MrMestri.buildJobs();
            int jobToken = 0;
            while (true) {
                if (jobStack.size() > 0) {
                    jobToken++;
                    MrRunnable worker = new MrRunnable(jobStack.pop());
                    executor.execute(worker);
                    if (jobToken % Integer.parseInt("4") == 0) {
                        // executor.shutdown();
                        System.out.println("short waiting...");
                        Thread.sleep(2000);

                    }
                } else {
                    System.out.println("long waiting...");
                    Thread.sleep(10000);
                    break;
                }
            }
        }
    }
}

class MrMestri {

    public static Stack<Job> buildJobs() {
        Stack<Job> stack = new Stack<Job>();
        stack.push(new Job("A"));
        stack.push(new Job("B"));
        stack.push(new Job("C"));
        stack.push(new Job("D"));
        stack.push(new Job("E"));
        stack.push(new Job("F"));
        return stack;
    }

}

class MrRunnable implements Runnable {
    private Job job;

    public MrRunnable(Job j) {
        job = j;
    }

    @Override
    public void run() {
        System.out.println(job.getName());
    }
}

class Job {
    private String name;

    public Job(String n) {
        name = n;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

等待线程在执行程序服务中完成

2 个答案: