Shulou(Shulou.com)06/02 Report--

This article mainly explains "what are the ExecutorAP types of Java concurrency framework". The content of the article is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn "what are the ExecutorAP types of Java concurrency framework?"

1. What is the Executor framework?

The Executor framework contains a set of components for effectively managing worker threads. Executor API decouples the execution of tasks from the actual tasks to be performed through Executors. This is an implementation of the producer-consumer model.

Java.util.concurrent.Executors provides a factory method for creating thread pools for worker threads.

To use the Executor framework, we need to create a thread pool and submit tasks to it for execution. The job of the Executor framework is to schedule and execute submitted tasks and get the returned results from the thread pool.

A basic question that comes to mind is why do we need thread pools when we create objects of java.lang.Thread or call parallelism of programs that implement the Runnable/Callable interface?

The answer comes from two fundamentals:

Creating a new thread for a new task has additional thread creation and destruction overhead. Managing the lifecycle of these threads significantly increases the execution time of CPU. Creating threads for each process without any restrictions results in the creation of a large number of threads. These threads take up a lot of memory and cause a waste of resources. When one thread uses CPU's time slice and another thread is about to take advantage of CPU's time slice, CPU spends a lot of time switching the thread's context.

All these factors will lead to a decline in the throughput of the system. Thread pools overcome this problem by keeping threads alive and reusing them. When more tasks are submitted to the thread pool than there are executing threads, those extra tasks are placed in the queue. Once the thread executing the task is free, they will take the next task from the queue to execute. This task queue is basically unbounded for off-the-shelf executors provided by JDK.

2. Type of Executors

Now that we know what executors is, let's look at the different types of executors.

2.1 SingleThreadExecutor

This thread pool executor has only one thread. It is used to perform tasks in a sequential manner. If this thread dies due to an exception while executing a task, a new thread is created to replace the thread, and subsequent tasks are executed in the new thread.

ExecutorService executorService = Executors.newSingleThreadExecutor ()

2.2 FixedThreadPool (n)

As the name implies, it is a thread pool with a fixed number of threads. Tasks submitted to executor are executed by fixed n threads, and if there are more tasks, they are stored in LinkedBlockingQueue. This number n is usually related to the total number of threads supported by the underlying processor.

ExecutorService executorService = Executors.newFixedThreadPool (4)

2.3 CachedThreadPool

This thread pool is mainly used in scenarios where a large number of short-term parallel tasks are performed. Unlike fixed thread pools, there is no limit to the number of threads in this thread pool. If all threads are busy executing tasks and new tasks arrive, the thread pool will create a new thread and submit it to executor. As long as one of the threads becomes idle, it performs the new task. If a thread is idle for 60 seconds, they will be terminated and deleted from the cache.

However, if the management is not reasonable, or if the task is not very short, the thread pool will contain a large number of active threads. This can lead to resource disorder and therefore performance degradation.

ExecutorService executorService = Executors.newCachedThreadPool ()

2.4 ScheduledExecutor

This type of executor is used when we have a task that needs to be run regularly or when we want to delay a task.

ScheduledExecutorService scheduledExecService = Executors.newScheduledThreadPool (1)

You can use scheduleAtFixedRate or scheduleWithFixedDelay to perform tasks on a regular basis in ScheduledExecutor.

ScheduledExecService.scheduleAtFixedRate (Runnable command, long initialDelay, long period, TimeUnit unit)

ScheduledExecService.scheduleWithFixedDelay (Runnable command, long initialDelay, long period, TimeUnit unit)

The main difference between these two methods is their response to delays between successive periodic tasks.

ScheduleAtFixedRate: whenever the previous task ends, the task is executed at regular intervals. ScheduleWithFixedDelay: the delayed countdown is started only after the current task is completed.

3. Understanding of Future objects

You can use the java.util.concurrent.Future object returned by executor to access the results of tasks submitted to executor. Future can be thought of as executor's response to the caller.

Future result = executorService.submit (callableTask)

As mentioned above, the task submitted to executor is asynchronous, meaning that instead of waiting for the current task to complete, the program goes straight to the next step. Instead, executor sets it in this Future object whenever the task completes execution.

The caller can continue to execute the main program, and when he needs to submit the result of the task, he can call the .get () method on the Future object to get it. If the task is completed, the result will be returned to the caller immediately, otherwise the caller will be blocked until executor finishes performing the operation and calculates the result.

If the caller cannot wait indefinitely for the result of the task execution, the wait time can also be set to be timed. This can be achieved through the Future.get (long timeout,TimeUnit unit) method, which throws a TimeoutException if no result is returned within the specified time range. The caller can handle this exception and continue to execute the program.

If an exception occurs during task execution, the call to the get method throws an ExecutionException.

One important thing about the results returned by the Future.get () method is that Future is returned only if the submitted task implements the java.util.concurrent.Callable interface. If the task implements the Runnable interface, the call to the .get () method returns null once the task is complete.

Another concern is the Future.cancel (boolean mayInterruptIfRunning) method. This method is used to cancel the execution of a submitted task. If the task is already executing, executor will attempt to interrupt the task execution if the mayInterruptIfRunning flag is true.

4. Example: create and execute a simple Executor

We will now create a task and try to execute it in fixed pool executor:

Public class Task implements Callable {private String message; public Task (String message) {this.message = message;} @ Override public String call () throws Exception {return "Hello" + message + "!;}}

The Task class implements the Callable interface and has a method of type String as the return value. This method can also throw an Exception. This ability to throw an exception to the executor and the ability of the executor to return the exception to the caller are important because it helps the caller know the status of the task execution.

Now let's perform this task:

Public class ExecutorExample {public static void main (String [] args) {Task task = new Task ("World"); ExecutorService executorService = Executors.newFixedThreadPool (4); Future result = executorService.submit (task); try {System.out.println (result.get ());} catch (InterruptedException | ExecutionException e) {System.out.println ("Error occured while executing the submitted task"); e.printStackTrace ();} executorService.shutdown ();}

We created a FixedThreadPool executors with four threads because the demo was developed on a quad-core processor. The number of threads may exceed the number of cores of the processor if the task being executed performs a large number of Igamot O operations or takes a long time to wait for external resources.

We instantiated the Task class and submitted it to executors execution. The result is returned by the Future object, and then we print it on the screen.

Let's run ExecutorExample and look at its output:

Hello World!

As expected, the task appends the greeting Hello and returns the result through Future object.

Finally, we call shutdown on the executorService object to terminate all threads and return resources to OS.

The .shutdown () method waits for executor to complete the currently submitted task. However, if the requirement is to shut down executor immediately without waiting, we can use the .shutdownNow () method.

Any task to be performed returns the result to the java.util.List object.

We can also create the same task by implementing the Runnable interface:

Public class Task implements Runnable {private String message; public Task (String message) {this.message = message;} public void run () {System.out.println ("Hello" + message + "!");}}

When we implement Runnable, there are some important changes.

The result of task execution cannot be obtained from the run () method. So, we print directly here.

The run () method cannot throw any checked exceptions.

Thank you for your reading, the above is the content of "what are the ExecutorAP types of Java concurrency framework?" after the study of this article, I believe you have a deeper understanding of what the ExecutorAP type of Java concurrency framework has, and the specific use needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.