ExecutorService วิธีรองานทั้งหมดให้เสร็จ

วิธีที่ง่ายที่สุดในการรอให้ภารกิจทั้งหมดExecutorServiceเสร็จสิ้นคืออะไร งานของฉันคือการคำนวณเป็นหลักดังนั้นฉันแค่ต้องการเรียกใช้งานจำนวนมาก - หนึ่งในแต่ละหลัก ตอนนี้การตั้งค่าของฉันมีลักษณะดังนี้:

ExecutorService es = Executors.newFixedThreadPool(2);
for (DataTable singleTable : uniquePhrases) {   
    es.execute(new ComputeDTask(singleTable));
}
try{
    es.wait();
} 
catch (InterruptedException e){
    e.printStackTrace();
}

ComputeDTaskใช้ runnable เรื่องนี้ดูเหมือนจะดำเนินงานได้อย่างถูกต้อง แต่รหัสเกิดปัญหาในด้วยwait() IllegalMonitorStateExceptionนี่เป็นเรื่องแปลกเพราะฉันเล่นไปด้วยตัวอย่างของเล่นและดูเหมือนว่ามันจะใช้ได้

uniquePhrasesมีองค์ประกอบหลายสิบหลายหมื่น ฉันควรใช้วิธีอื่นหรือไม่? ฉันกำลังมองหาบางอย่างที่ง่ายที่สุด

วิธีที่ง่ายที่สุดคือการใช้ExecutorService.invokeAll()ซึ่งทำสิ่งที่คุณต้องการในหนึ่งซับ ในการพูดจาของคุณคุณจะต้องปรับเปลี่ยนหรือห่อComputeDTaskเพื่อนำไปใช้Callable<>ซึ่งจะทำให้คุณมีความยืดหยุ่นมากขึ้น อาจจะอยู่ในแอปของคุณมีการดำเนินงานที่มีความหมายของแต่นี่เป็นวิธีที่จะตัดมันถ้าไม่ได้ใช้Callable.call()Executors.callable()

ExecutorService es = Executors.newFixedThreadPool(2);
List<Callable<Object>> todo = new ArrayList<Callable<Object>>(singleTable.size());

for (DataTable singleTable: uniquePhrases) { 
    todo.add(Executors.callable(new ComputeDTask(singleTable))); 
}

List<Future<Object>> answers = es.invokeAll(todo);

ตามที่คนอื่น ๆ ได้ชี้ให้เห็นคุณสามารถใช้เวอร์ชันไทม์เอาต์ของinvokeAll()ถ้าเหมาะสม ในตัวอย่างanswersนี้จะมีกลุ่มของFutures ซึ่งจะคืนค่าเป็นศูนย์ (ดูคำนิยามของExecutors.callable()อาจเป็นสิ่งที่คุณต้องการทำคือ refactoring เล็กน้อยเพื่อให้คุณได้รับคำตอบที่เป็นประโยชน์กลับหรืออ้างอิงถึงพื้นฐานComputeDTaskแต่ฉันสามารถ บอกจากตัวอย่างของคุณ

หากยังไม่ชัดเจนโปรดทราบว่าinvokeAll()จะไม่ส่งคืนจนกว่างานทั้งหมดจะเสร็จสิ้น (เช่นทั้งหมดFutureในanswersคอลเลกชันของคุณจะรายงาน.isDone()หากถูกถาม) สิ่งนี้จะหลีกเลี่ยงการปิดระบบด้วยตนเองทั้งหมดรอการประกาศ ฯลฯ และช่วยให้คุณสามารถนำสิ่งนี้กลับมาใช้ใหม่ได้ExecutorServiceอย่างเป็นระเบียบหากต้องการ

มีคำถามที่เกี่ยวข้องสองสามข้อเกี่ยวกับ SO:

• วิธีรอเธรดทั้งหมดให้เสร็จสิ้น

• ส่งคืนค่าจากเธรด java

• invokeAll () ไม่ต้องการรับคอลเล็กชัน <Callable <t>>

• ฉันจำเป็นต้องซิงโครไนซ์หรือไม่

สิ่งเหล่านี้ไม่ตรงประเด็นสำหรับคำถามของคุณ แต่พวกเขาให้สีเล็กน้อยเกี่ยวกับวิธีที่คนคิดExecutor/ ExecutorServiceควรใช้

หากคุณต้องการที่จะรอสำหรับงานทั้งหมดจะเสร็จสมบูรณ์ให้ใช้วิธีการแทนshutdown จากนั้นตามด้วย waitawaitTermination

นอกจากนี้คุณสามารถใช้Runtime.availableProcessorsเพื่อรับจำนวนเธรดฮาร์ดแวร์เพื่อให้คุณสามารถเริ่มต้นเธรดพูลของคุณได้อย่างถูกต้อง

ถ้ารอให้งานทั้งหมดในExecutorServiceที่จะเสร็จสิ้นไม่ได้เป็นเป้าหมายของคุณได้อย่างแม่นยำ แต่รอจนกว่าจะมีชุดเฉพาะของงานที่เสร็จสมบูรณ์แล้วคุณสามารถใช้CompletionService- ExecutorCompletionServiceโดยเฉพาะการ

ความคิดที่จะสร้างExecutorCompletionServiceการวางรูปภาพของคุณExecutor, ส่งบางส่วนจำนวนที่รู้จักกันของงานผ่านCompletionServiceแล้ววาดที่หมายเลขเดียวกันของผลที่ได้จากคิวเสร็จสิ้นโดยใช้take()(ซึ่งบล็อก) หรือpoll()(ซึ่งไม่ได้) เมื่อคุณวาดผลลัพธ์ที่คาดหวังทั้งหมดที่สอดคล้องกับงานที่คุณส่งคุณจะรู้ว่าพวกเขาทำเสร็จ

ให้ฉันบอกอีกครั้งนี้เพราะมันไม่ชัดเจนจากอินเทอร์เฟซ: คุณต้องรู้ว่าคุณใส่อะไรลงCompletionServiceไปบ้างเพื่อที่จะได้รู้ว่าต้องพยายามดึงออกมาเท่าไหร่ เรื่องนี้โดยเฉพาะอย่างยิ่งกับtake()วิธีการ: เรียกว่าครั้งหนึ่งมากเกินไปและจะป้องกันด้ายเรียกร้องของคุณจนกว่าส่งหัวข้ออื่น ๆ CompletionServiceงานอื่นไปเหมือนกัน

มีตัวอย่างบางส่วนที่แสดงวิธีการใช้CompletionServiceในหนังสือJava Concurrency ในการปฏิบัติ

หากคุณต้องการที่จะรอสำหรับการให้บริการผู้บริหารที่จะเสร็จสิ้นการดำเนินการโทรshutdown()แล้วawaitTermination (หน่วย UNITTYPE)awaitTermination(1, MINUTE)เช่น ExecutorService ไม่ได้ปิดกั้นหน้าจอของตัวเองดังนั้นคุณจึงไม่สามารถใช้งานได้waitฯลฯ

คุณสามารถรอให้งานเสร็จในช่วงเวลาหนึ่ง:

int maxSecondsPerComputeDTask = 20;
try {
    while (!es.awaitTermination(uniquePhrases.size() * maxSecondsPerComputeDTask, TimeUnit.SECONDS)) {
        // consider giving up with a 'break' statement under certain conditions
    }
} catch (InterruptedException e) {
    throw new RuntimeException(e);    
}

หรือคุณอาจจะใช้ExecutorService ส่ง ( Runnable ) และรวบรวมวัตถุในอนาคตที่ส่งคืนและเรียกใช้get ()ในแต่ละรายการเพื่อรอให้เสร็จสิ้น

ExecutorService es = Executors.newFixedThreadPool(2);
Collection<Future<?>> futures = new LinkedList<<Future<?>>();
for (DataTable singleTable : uniquePhrases) {
    futures.add(es.submit(new ComputeDTask(singleTable)));
}
for (Future<?> future : futures) {
   try {
       future.get();
   } catch (InterruptedException e) {
       throw new RuntimeException(e);
   } catch (ExecutionException e) {
       throw new RuntimeException(e);
   }
}

InterruptExceptionเป็นสิ่งสำคัญอย่างยิ่งในการจัดการอย่างถูกต้อง เป็นสิ่งที่ช่วยให้คุณหรือผู้ใช้ไลบรารีของคุณยุติกระบวนการที่ยาวนานได้อย่างปลอดภัย

เพียงแค่ใช้

latch = new CountDownLatch(noThreads)

ในแต่ละกระทู้

latch.countDown();

และเป็นอุปสรรค

latch.await();

สาเหตุหลักสำหรับIllegalMonitorStateException :

โยนเพื่อระบุว่าเธรดพยายามรอจอภาพของวัตถุหรือแจ้งเตือนเธรดอื่น ๆ ที่รอบนจอภาพของวัตถุโดยไม่ได้เป็นเจ้าของจอภาพที่ระบุ

จากรหัสของคุณคุณเพิ่งเรียกว่า wait () บน ExecutorService โดยไม่ต้องเป็นเจ้าของล็อค

รหัสด้านล่างจะแก้ไข IllegalMonitorStateException

try 
{
    synchronized(es){
        es.wait(); // Add some condition before you call wait()
    }
} 

ExecutorServiceทำตามอย่างใดอย่างหนึ่งดังต่อไปนี้วิธีการรอให้เสร็จสิ้นของงานทั้งหมดที่ได้รับการส่งไปยัง

1. วนซ้ำทุกFutureภารกิจจากsubmitเปิดExecutorServiceและตรวจสอบสถานะด้วยการบล็อคการโทรget()บนFutureวัตถุ

2. ใช้invokeAllเปิดExecutorService

3. ใช้CountDownLatch

4. ใช้ForkJoinPoolหรือnewWorkStealingPoolของExecutors(ตั้งแต่ java 8)

5. ปิดพูลตามที่แนะนำในหน้าเอกสารของ oracle

   void shutdownAndAwaitTermination(ExecutorService pool) {
      pool.shutdown(); // Disable new tasks from being submitted
      try {
      // Wait a while for existing tasks to terminate
      if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
          pool.shutdownNow(); // Cancel currently executing tasks
          // Wait a while for tasks to respond to being cancelled
          if (!pool.awaitTermination(60, TimeUnit.SECONDS))
          System.err.println("Pool did not terminate");
      }
   } catch (InterruptedException ie) {
        // (Re-)Cancel if current thread also interrupted
        pool.shutdownNow();
        // Preserve interrupt status
        Thread.currentThread().interrupt();
   }

   หากคุณต้องการรอให้งานทั้งหมดเสร็จสิ้นอย่างสง่างามเมื่อคุณใช้ตัวเลือกที่ 5 แทนตัวเลือกที่ 1 ถึง 4 ให้เปลี่ยน

   if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {

   ถึง

   while(condition)ซึ่งการตรวจสอบสำหรับทุก 1 นาที

คุณสามารถใช้ExecutorService.invokeAllวิธีการมันจะทำงานทั้งหมดและรอจนกว่ากระทู้ทั้งหมดเสร็จงานของพวกเขา

นี่คือjavadoc ที่สมบูรณ์

คุณยังสามารถใช้วิธีการนี้มากเกินไปเพื่อระบุการหมดเวลา

นี่คือตัวอย่างรหัสด้วย ExecutorService.invokeAll

public class Test {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService service = Executors.newFixedThreadPool(3);
        List<Callable<String>> taskList = new ArrayList<>();
        taskList.add(new Task1());
        taskList.add(new Task2());
        List<Future<String>> results = service.invokeAll(taskList);
        for (Future<String> f : results) {
            System.out.println(f.get());
        }
    }

}

class Task1 implements Callable<String> {
    @Override
    public String call() throws Exception {
        try {
            Thread.sleep(2000);
            return "Task 1 done";
        } catch (Exception e) {
            e.printStackTrace();
            return " error in task1";
        }
    }
}

class Task2 implements Callable<String> {
    @Override
    public String call() throws Exception {
        try {
            Thread.sleep(3000);
            return "Task 2 done";
        } catch (Exception e) {
            e.printStackTrace();
            return " error in task2";
        }
    }
}

ฉันยังมีสถานการณ์ที่ฉันมีชุดเอกสารที่จะรวบรวมข้อมูล ฉันเริ่มต้นด้วยเอกสาร "seed" เริ่มต้นที่ควรประมวลผลเอกสารนั้นมีลิงก์ไปยังเอกสารอื่นที่ควรประมวลผลและอื่น ๆ

ในโปรแกรมหลักของฉันฉันต้องการเขียนสิ่งต่อไปนี้ซึ่งCrawlerควบคุมกลุ่มของเธรด

Crawler c = new Crawler();
c.schedule(seedDocument); 
c.waitUntilCompletion()

สถานการณ์เดียวกันจะเกิดขึ้นถ้าฉันต้องการนำทางต้นไม้; ฉันจะปรากฏในโหนดรูทหน่วยประมวลผลสำหรับแต่ละโหนดจะเพิ่มลูกลงในคิวตามความจำเป็นและกลุ่มของเธรดจะประมวลผลโหนดทั้งหมดในทรีจนกว่าจะไม่มีอีกต่อไป

ฉันไม่พบอะไรเลยใน JVM ที่ฉันคิดว่าน่าแปลกใจเล็กน้อย ดังนั้นฉันจึงเขียนชั้นเรียนที่หนึ่งที่สามารถใช้โดยตรงหรือประเภทรองเพื่อเพิ่มวิธีการที่เหมาะสมสำหรับโดเมนเช่นThreadPool schedule(Document)หวังว่ามันจะช่วย!

ThreadPool Javadoc | Maven

invokeAllเพิ่มหัวข้อทั้งหมดในการเก็บรวบรวมและส่งไปใช้ หากคุณสามารถใช้invokeAllวิธีการได้ExecutorServiceJVM จะไม่ดำเนินการไปยังบรรทัดถัดไปจนกว่าเธรดทั้งหมดจะเสร็จสมบูรณ์

นี่คือตัวอย่างที่ดี: เรียกใช้ทั้งหมดผ่าน ExecutorService

ส่งงานของคุณไปที่Runnerแล้วรอเรียกเมธอดwaitTillDone ()ดังนี้:

Runner runner = Runner.runner(2);

for (DataTable singleTable : uniquePhrases) {

    runner.run(new ComputeDTask(singleTable));
}

// blocks until all tasks are finished (or failed)
runner.waitTillDone();

runner.shutdown();

หากต้องการใช้เพิ่มการพึ่งพา gradle / Maven นี้: 'com.github.matejtymes:javafixes:1.0'

สำหรับรายละเอียดเพิ่มเติมดูที่นี่: https://github.com/MatejTymes/JavaFixesหรือที่นี่: http://matejtymes.blogspot.com/2016/04/executor-that-notifies-you-when-task.html

ทางเลือกง่าย ๆ สำหรับสิ่งนี้คือการใช้เธรดพร้อมกับการเข้าร่วม อ้างอิง: การเข้าร่วมเธรด

ฉันจะรอให้ผู้ดำเนินการสิ้นสุดเวลาที่กำหนดซึ่งคุณคิดว่าเหมาะสมสำหรับงานที่ต้องทำให้เสร็จ

 try {  
         //do stuff here 
         exe.execute(thread);
    } finally {
        exe.shutdown();
    }
    boolean result = exe.awaitTermination(4, TimeUnit.HOURS);
    if (!result)

    {
        LOGGER.error("It took more than 4 hour for the executor to stop, this shouldn't be the normal behaviour.");
    }

ฟังดูเหมือนคุณต้องการForkJoinPoolและใช้พูลส่วนกลางเพื่อดำเนินงาน

public static void main(String[] args) {
    // the default `commonPool` should be sufficient for many cases.
    ForkJoinPool pool = ForkJoinPool.commonPool(); 
    // The root of your task that may spawn other tasks. 
    // Make sure it submits the additional tasks to the same executor that it is in.
    Runnable rootTask = new YourTask(pool); 
    pool.execute(rootTask);
    pool.awaitQuiescence(...);
    // that's it.
}

ความงามอยู่ในpool.awaitQuiescenceที่วิธีการที่จะป้องกันการใช้ด้ายที่โทรมาในการดำเนินงานและจากนั้นกลับมาเมื่อมันเป็นจริงๆที่ว่างเปล่า