Interface ng ExecutorService

Bakit kailangan mo ang Executor interface?

Bago ang Java 5, kailangan mong isulat ang lahat ng iyong sariling pamamahala sa thread ng code sa iyong aplikasyon. Bilang karagdagan, ang paglikha ng isangbagong Threadobject ay isang resource-intensive na operasyon, at hindi makatuwirang gumawa ng bagong thread para sa bawat magaan na gawain. At dahil pamilyar ang problemang ito sa ganap na bawat developer ng mga multi-threaded na application, nagpasya silang dalhin ang functionality na ito sa Java bilang framework ng Executor .

Ano ang malaking ideya? Ito ay simple: sa halip na lumikha ng isang bagong thread para sa bawat bagong gawain, ang mga thread ay pinananatili sa isang uri ng "imbakan", at kapag dumating ang isang bagong gawain, kumukuha kami ng isang umiiral na thread sa halip na lumikha ng bago.

Ang mga pangunahing interface ng framework na ito ay Executor , ExecutorService at ScheduledExecutorService , bawat isa ay nagpapalawak ng functionality ng nauna.

Ang Interface ng Executor ay ang base interface. Nagdedeklara ito ng isang paraan ng void execute(Runnable command) na ipinapatupad ng isang Runnable object.

Ang interface ng ExecutorService ay mas kawili-wili. Mayroon itong mga pamamaraan para sa pamamahala sa pagkumpleto ng trabaho, pati na rin mga pamamaraan para sa pagbabalik ng ilang uri ng resulta. Tingnan natin ang mga pamamaraan nito nang mas malapitan:

Tingnan natin ang isang maliit na halimbawa ng pagtatrabaho sa ExecutorService .

import java.util.List;
import java.util.concurrent.*;

public class ExecutorServiceTest {
   public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
//Create an ExecutorService for 2 threads
       java.util.concurrent.ExecutorService executorService = new ThreadPoolExecutor(2, 2, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10));
// Create 5 tasks
       MyRunnable task1 = new MyRunnable();
       MyRunnable task2 = new MyRunnable();
       MyRunnable task3 = new MyRunnable();
       MyRunnable task4 = new MyRunnable();
       MyRunnable task5 = new MyRunnable();

       final List<MyRunnable> tasks = List.of(task1, task2, task3, task4, task5);
// Pass a list that contains the 5 tasks we created
       final List<Future<Void>> futures = executorService.invokeAll(tasks, 6, TimeUnit.SECONDS);
       System.out.println("Futures received");

// Stop the ExecutorService
       executorService.shutdown();

       try {
           TimeUnit.SECONDS.sleep(3);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

       System.out.println(executorService.isShutdown());
       System.out.println(executorService.isTerminated());
   }

   public static class MyRunnable implements Callable<Void> {

       @Override
       public void call() {
// Add 2 delays. When the ExecutorService is stopped, we will see which delay is in progress when the attempt is made to stop execution of the task
           try {
               TimeUnit.SECONDS.sleep(3);
           } catch (InterruptedException e) {
               System.out.println("sleep 1: " + e.getMessage());
           }
           try {
               TimeUnit.SECONDS.sleep(2);
           } catch (InterruptedException e) {
               System.out.println("sleep 2: " + e.getMessage());
           }
           System.out.println("done");
           return null;
       }
   }
}

Output:

Ang bawat gawain ay tumatakbo nang 5 segundo. Gumawa kami ng pool para sa dalawang thread, kaya ang unang dalawang linya ng output ay may perpektong kahulugan.

Anim na segundo pagkatapos magsimula ang programa, ang invokeAll na pamamaraan ay nag-time out at ang resulta ay ibinalik bilang isang listahan ng Futures . Ito ay makikita mula sa output string Futures na natanggap .

Matapos magawa ang unang dalawang gawain, magsisimula pa ang dalawa. Ngunit dahil lumipas ang timeout na itinakda sa invokeAll na paraan, ang dalawang gawaing ito ay walang oras upang makumpleto. Nakatanggap sila ng utos na "kanselahin" . Iyon ang dahilan kung bakit ang output ay may dalawang linya na may sleep 1: sleep interrupted .

At pagkatapos ay makakakita ka ng dalawa pang linya na may tapos na . Ito ang side effect na binanggit ko noong inilalarawan ang invokeAll method.

Ang ikalimang at panghuling gawain ay hindi pa nasisimulan, kaya wala kaming nakikitang anuman tungkol dito sa output.

Ang huling dalawang linya ay ang resulta ng pagtawag sa isShutdown at isTerminated na pamamaraan.

Interesante ding patakbuhin ang halimbawang ito sa debug mode at tingnan ang status ng gawain pagkatapos lumipas ang timeout (magtakda ng breakpoint sa linya gamit ang executorService.shutdown(); ):

Nakita namin na dalawang gawain ang Nakumpleto nang normal , at tatlong gawain ang "Kinansela" .

ScheduledExecutorService

Upang tapusin ang aming talakayan ng mga tagapagpatupad, tingnan natin ang ScheduledExecutorService .

Mayroon itong 4 na pamamaraan: