Java Executor framework learning Summary

Java Executor framework learning Summary

Most concurrency is implemented through task execution. Generally, there are two ways to execute a task: Serial and parallel.

 
 

  
  
class SingleThreadWebServer { 
  
  
    public static void main(String[] args) throws Exception { 
  
  
        ServerSocket socket = new ServerSocket(80); 
  
  
        while(true) { 
  
  
            Socket conn = socket.accept(); 
  
  
            handleRequest(conn); 
  
  
        } 
  
  
    } 
  
  
} 
  
  
 
  
  
class ThreadPerTaskWebServer { 
  
  
    public static void main(String[] args) throws Exception { 
  
  
        ServerSocket socket = new ServerSocket(80); 
  
  
        while(true) { 
  
  
            final Socket conn = socket.accept(); 
  
  
            Runnable task = new Runnable() { 
  
  
                public void run() { 
  
  
                    handleRequest(conn); 
  
  
                } 
  
  
            }; 
  
  
            new Thread(task).start(); 
  
  
        } 
  
  
    } 
  
  
} 
 
 

Of course the above two methods are problematic. The single thread problem is that the concurrency will be the bottleneck, and the multi-threaded version means that unlimited thread creation will lead to insufficient resources.

ExecutorFramework

A task is a group of logical units of work, while a thread is a mechanism for asynchronous execution of the task.

JDK provides the Executor interface:

 
 

  
  
public interface Executor { 
  
  
    void execute(Runnable command); 
  
  
} 
 
 

Although the Executor interface is relatively simple, it is the basis of the asynchronous task execution framework. This framework supports various types of task execution policies. It provides a standard way to understand the process of task submission and execution. Runnable is used to represent tasks. Executor provides support for the lifecycle and management of statistical information applications.

Executor is based on the producer consumer mode. The operations for submitting a task are equivalent to those for the producer, and the threads for executing the task are equivalent to the consumption.

An example of Executor-based WebServer is as follows:

 
 

  
  
public class TaskExecutorWebServer { 
  
  
    private static final int NTHREADS = 100; 
  
  
    private static final Executor exec = Executors.newFixedThreadPool(NTHREADS); 
  
  
 
  
  
    public static void main(String[] args) throws Exception { 
  
  
        ServerSocket serverSocket = new ServerSocket(80); 
  
  
        while (true) { 
  
  
            final Socket conn = serverSocket.accept(); 
  
  
            Runnable task = new Runnable() { 
  
  
                @Override 
  
  
                public void run() { 
  
  
                    handleRequest(conn); 
  
  
                } 
  
  
            }; 
  
  
            exec.execute(task); 
  
  
        } 
  
  
    } 
  
  
} 
 
 

In addition, you can implement Executor to control concurrency or parallelism, as shown in the following code:

 
 

  
  
/**
  
  
* The object that executes the submitted Runnable task.
  
  
* This interface provides a way to separate job submission from how each job runs, including the details of thread usage and scheduling.
  
  
* Generally, Executor is used instead of explicitly creating a thread.
  
  
*
  
  
*
  
  
* @ Author renchunxiao
  
  
*
  
  
*/
  
  
Public class ExecutorDemo {
  
  
Public static void main (String [] args ){
  
  
Executor executor = new ThreadExecutor ();
  
  
Executor.exe cute (new Runnable (){
  
  
@ Override
  
  
Public void run (){
  
  
// Do something
  
  
}
  
  
});
  
  
 
  
  
Executor executor2 = new SerialExecutor ();
  
  
Executor2.execute (new Runnable (){
  
  
@ Override
  
  
Public void run (){
  
  
// Do something
  
  
}
  
  
});
  
  
 
  
  
}
  
  
}
  
  
 
  
  
/**
  
  
* Create a thread to Execute command
  
  
*
  
  
* @ Author renchunxiao
  
  
*
  
  
*/
  
  
Class ThreadExecutor implements Executor {
  
  
@ Override
  
  
Public void execute (Runnable command ){
  
  
New Thread (command). start ();
  
  
}
  
  
}
  
  
 
  
  
/**
  
  
* Execute command serially
  
  
*
  
  
* @ Author renchunxiao
  
  
*
  
  
*/
  
  
Class SerialExecutor implements Executor {
  
  
@ Override
  
  
Public void execute (Runnable command ){
  
  
Command. run ();
  
  
}
  
  
}
 
 

Thread Pool

The thread pool is the thread resource pool. You can use the static factory method in Executors to create a thread pool.

• NewFixedThreadPool. Create a thread pool with a fixed length. Create a thread for each submitted task until the maximum number of threads reaches the thread pool. The size of the thread pool does not change.

• NewSingleThreadExecutor. A single thread pool.

• NewCachedThreadPool. The thread pool varies according to the task scale.

• NewScheduledThreadPool. Create a fixed-length thread pool to execute tasks in a delayed or scheduled manner.

JVM exits only after all non-daemon threads are terminated. Therefore, if Executor cannot be properly disabled, the JVM cannot end.

To solve the Life Cycle Problem of the Execution Service, a new interface called ExecutorService that extends the Executor interface is provided.

 
 

  
  
public interface ExecutorService extends Executor { 
  
  
 
  
  
    void shutdown(); 
  
  
 
  
  
    List<Runnable> shutdownNow(); 
  
  
 
  
  
    boolean isShutdown(); 
  
  
 
  
  
    boolean isTerminated(); 
  
  
 
  
  
    boolean awaitTermination(long timeout, TimeUnit unit) 
  
  
        throws InterruptedException; 
  
  
 
  
  
    <T> Future<T> submit(Callable<T> task); 
  
  
 
  
  
    <T> Future<T> submit(Runnable task, T result); 
  
  
 
  
  
    Future<?> submit(Runnable task); 
  
  
 
  
  
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) 
  
  
        throws InterruptedException; 
  
  
 
  
  
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, 
  
  
                                  long timeout, TimeUnit unit) 
  
  
        throws InterruptedException; 
  
  
 
  
  
    <T> T invokeAny(Collection<? extends Callable<T>> tasks) 
  
  
        throws InterruptedException, ExecutionException; 
  
  
 
  
  
    <T> T invokeAny(Collection<? extends Callable<T>> tasks, 
  
  
                    long timeout, TimeUnit unit) 
  
  
        throws InterruptedException, ExecutionException, TimeoutException; 
  
  
} 
 
 

ExecutorService has three statuses: running, closed, and terminated. ExecutorService is running at initial creation. The shutdown method is gentle: Do not accept new tasks, and wait until the executed tasks are completed (including those that have not yet started ). The shutdownNow method will roughly close: it will try to cancel all running tasks and stop Starting tasks not started in the queue. After all tasks are completed, they enter the terminated state.

Callable and Future

The Executor framework uses Runnable as the basic task representation. Runnable is a restricted abstraction. Its run method cannot return a value or throw a checked exception.

In fact, many tasks involve computing delays, such as database queries, and retrieving resources from the network. For these tasks, Callable is a better abstraction. It deems that call will return a value and may throw an exception.

Executor executes tasks in four lifecycles: creation, submission, start, and completion. Some tasks may need to be canceled for a long time. In the Executor framework, tasks that have not been submitted can be canceled.

Future indicates the life cycle of a task, and provides methods to determine whether the task has been completed or canceled, as well as to obtain the task result and cancel the task.