Android custom thread pool programming practice

1. Introduction to Executor

After Java 5, concurrent programming introduced a bunch of new APIs for starting, scheduling, and managing threads. The Executor framework was introduced in Java 5, which uses a thread pool mechanism internally. It is under the java.util.cocurrent package. Through this framework, you can control the startup, execution, and shutdown of threads, which can simplify concurrent programming operations. Therefore, after Java 5, starting threads through Executor is better than using the start method of Thread. In addition to being easier to manage and more efficient (implemented with a thread pool to save overhead), there is another key point: it helps avoid the this escape problem - if we start a thread in the constructor, because another task may start executing before the constructor ends, it may access a half-initialized object using Executor in the constructor.

The Executor framework includes: thread pool, Executor, Executors, ExecutorService, CompletionService, Future, Callable, etc.

In the Java code, Executor is an interface with only one method.

 public interface Executor { 
  
 /**
     * Executes the given command at   some   time   in the future. The command
 * may execute   in a new thread, in a pooled thread, or   in the calling
     * thread, at the discretion of the {@code Executor} implementation.
 *
     * @param command the runnable task
     * @throws RejectedExecutionException if this task cannot be
 * accepted for execution
     * @throws NullPointerException if command is   null  
 */
    void execute (Runnable command);
 }

2. ExecutorService

ExecutorService is an interface that inherits Executor. In addition to the execute(Runnable command) method, it also extends other methods:

 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); //Submit a task
• <T> Future<T> submit(Runnable task, T result); //Submit a task
• Future<?> submit(Runnable task); //Submit a 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;

2.1 execute(Runnable)

Receives a java.lang.Runnable object as a parameter and executes it asynchronously. The following is an example of using ExecutorService to execute Runnable

 package com.app; 
 
 import java.util.concurrent.ExecutorService; 
 
 import java.util.concurrent.Executors; 
 
 public class ExecutorTest { 
 
 public   static void main(String[] args) { 
 
 //Create a thread pool with a fixed size of 10 threads 
 
 ExecutorService executorService = Executors.newFixedThreadPool( 10 ); 
 
 //Execute a task. The task is a new Runnable() object. 
 
 executorService.execute (new Runnable() { 
 
 @Override 
 
 public void run() { 
 
 Log.d( Thread.currentThread().getName() ); 
 
 } 
 
 }); 
 
 //Close the thread pool 
 
 executorService.shutdown(); 
 
 } 
 
 }

result:

 pool-1-thread-1

There is no way to get the result after executing Runnable using this method. If you want to get the return value after running, you must use the execute() method that receives the Callable parameter, which will be mentioned below.

2.2、submit(Runnable)

The method submit(Runnable) also receives a Runnable implementation as a parameter, but returns a Future object. This Future object can be used to determine whether the Runnable has finished executing. The following is an example of the submit() method of ExecutorService:

 package com.app; 
 
 import java.util.concurrent.ExecutorService; 
 
 import java.util.concurrent.Executors; 
 
 import java.util.concurrent.Future; 
 
 public class ExecutorTest { 
 
 public   static void main(String[] args) { 
 
 //Create a thread pool with a fixed size of 10 threads 
 
 ExecutorService executorService = Executors.newFixedThreadPool( 10 ); 
 
 //Execute a task. The task is a new Runnable() object. 
 
 Future future = executorService.submit( new Runnable() { 
 
 @Override 
 
 public void run() { 
 
 Log.d( Thread.currentThread().getName() ); 
 
 } 
 
 }); 
 
 try { 
 
 // If the task is finished executing, return null   
 
 Log.d( "" + future.get() ); 
 
 } catch (Exception e) { 
 
 e.printStackTrace(); 
 
 } 
 
 //Close the thread pool 
 
 executorService.shutdown(); 
 
 } 
 
 }

result:

 pool-1-thread-1 
 
 null  

2.3 submit(Callable)

The methods submit(Callable) and submit(Runnable) are similar, but the difference is that they accept different parameter types. Callable instances are very similar to Runnable instances, but the call() method of Callable can return a result. The method Runnable.run() cannot return a result.

The return value of Callable can be obtained from the Future object returned by the submit(Callable) method. The following is an example of ExecutorService Callable:

 package com.app; 
 
 import java.util.concurrent.Callable; 
 
 import java.util.concurrent.ExecutorService; 
 
 import java.util.concurrent.Executors; 
 
 import java.util.concurrent.Future; 
 
 public class ExecutorTest { 
 
 public   static void main(String[] args) { 
 
 //Create a thread pool with a fixed size of 10 threads 
 
 ExecutorService executorService = Executors.newFixedThreadPool( 10 ); 
 
 //Execute a task. The task is a new Callable() object. 
 
 Future future = executorService.submit( new Callable<String>() { 
 
 @Override 
 
 public String call() throws Exception { 
 
 return   "Execution completed" ; 
 
 } 
 
 }) ; 
 
 try { 
 
 // If the task is finished executing, return 
 
 Log.d( "The result is: " + future.get()); 
 
 } catch (Exception e) { 
 
 e.printStackTrace(); 
 
 } 
 
 //Close the thread pool 
 
 executorService.shutdown(); 
 
 } 
 
 }

result:

The result is: Execution completed

2.4、inVokeAny()

The invokeAny() method receives a collection of Callable objects as a parameter. Calling this method does not return a Future object, but returns the result of a Callable object in the collection. There is no guarantee which Callable the result will be after the call, but only that it is a Callable object that has finished executing. If a task is completed or an exception is thrown, the method will cancel the execution of other Callables.

 package com.app; 
 
 import java.util.ArrayList; 
 
 import java.util.List; 
 
 import java.util.concurrent.Callable; 
 
 import java.util.concurrent.ExecutionException; 
 
 import java.util.concurrent.ExecutorService; 
 
 import java.util.concurrent.Executors; 
 
 public class ExecutorTest { 
 
 public   static void main(String[] args) { 
 
 //Create a thread pool with a fixed size of 10 threads 
 
 ExecutorService executorService = Executors.newFixedThreadPool( 10 ); 
 
 List<Callable<String>> list = new ArrayList<>(); 
 
 //Create *** Callable 
 
 Callable<String> callable1 = new Callable<String>() { 
 
 @Override 
 
 public String call() throws Exception { 
 
 Log.d( "callable 1 thread is: " + Thread.currentThread().getName() ); 
 
 return   "Completed executing callable 1" ; 
 
 } 
 
 }; 
 
 //Create the second Callable 
 
 Callable<String> callable2 = new Callable<String>() { 
 
 @Override 
 
 public String call() throws Exception { 
 
 Log.d( "callable 2 thread is: " + Thread.currentThread().getName() ); 
 
 return   "Completed executing callable 2" ; 
 
 } 
 
 }; 
 
 list. add ( callable1 ) ; 
 
 list. add ( callable2 ) ; 
 
 try { 
 
 String result = executorService.invokeAny( list ); 
 
 Log.d( "The result is: " + result); 
 
 } catch (InterruptedException e1) { 
 
 e1.printStackTrace(); 
 
 } catch (ExecutionException e1) { 
 
 e1.printStackTrace(); 
 
 } 
 
 //Close the thread pool 
 
 executorService.shutdown(); 
 
 } 
 
 }

result:

The callable 1 thread is: pool-1-thread-1

The callable 2 thread is: pool-1-thread-2

The result is: Callable 2 has been executed

Summarize:

1. You can see that the call methods in Callable are all run in the child thread.

2. executorService.invokeAny( list ); The return value is the return value of any Callable. Any one is possible.

2.5, invokeAll()

The method invokeAll() calls all Callable objects in the parameter collection and returns a collection of Future objects. You can use this returned collection to manage the execution results of each Callable. It should be noted that a task may end due to an exception, so it may not really run successfully. But we have no way to understand this difference through Future objects.

 package com.app; 
 
 import java.util.ArrayList; 
 
 import java.util.List; 
 
 import java.util.concurrent.Callable; 
 
 import java.util.concurrent.ExecutorService; 
 
 import java.util.concurrent.Executors; 
 
 import java.util.concurrent.Future; 
 
 public class ExecutorTest { 
 
 public   static void main(String[] args) { 
 
 //Create a thread pool with a fixed size of 10 threads 
 
 ExecutorService executorService = Executors.newFixedThreadPool( 10 ); 
 
 List<Callable<String>> list = new ArrayList<>(); 
 
 //Create *** Callable 
 
 Callable<String> callable1 = new Callable<String>() { 
 
 @Override 
 
 public String call() throws Exception { 
 
 Log.d( "callable 1 thread is: " + Thread.currentThread().getName() ); 
 
 return   "Completed executing callable 1" ; 
 
 } 
 
 }; 
 
 //Create the second Callable 
 
 Callable<String> callable2 = new Callable<String>() { 
 
 @Override 
 
 public String call() throws Exception { 
 
 Log.d( "callable 2 thread is: " + Thread.currentThread().getName() ); 
 
 return   "Completed executing callable 2" ; 
 
 } 
 
 }; 
 
 list. add ( callable1 ) ; 
 
 list. add ( callable2 ) ; 
 
 List<Future<String>> result; 
 
 try { 
 
 result = executorService.invokeAll(list); 
 
 for (Future<String> future : result) { 
 
 Log.d( "The result is: " + future.get()); 
 
 } 
 
 } catch (Exception e) { 
 
 e.printStackTrace(); 
 
 } 
 
 //Close the thread pool 
 
 executorService.shutdown(); 
 
 } 
 
 }

result

The callable 1 thread is: pool-1-thread-1

The callable 2 thread is: pool-1-thread-2

The result is: Callable 1 has been executed

The result is: Callable 2 has been executed

Note: 1: The call method of Callable is executed in the child thread

2: executorService.invokeAll( list ) is the return value. However, it will only be returned after all Callable objects have been executed. The return value is a list, and the order is the same as List<Callable>. During the execution process, if any Callable has an exception, the program will crash and no value will be returned.

2.6 How to shut down the ExecuteService service?

When you are done using the ExecutorService, you should close it to ensure that the threads do not continue to run. For example, if your program is started through the main() method and the main thread exits your program, if you still have an active ExecutorService in your program, then the program will continue to run. Active threads in the ExecutorService will prevent the Java virtual machine from shutting down.

To shut down the threads in the ExecutorService, you need to call the shutdown() method. The ExecutorService does not shut down immediately, but stops accepting new tasks. Once all threads finish executing the current tasks, the ExecutorServie will be truly shut down. All tasks submitted to the ExecutorService before calling the shutdown() method will be executed.

If you want to shut down the ExecutorService immediately, you can call shutdownNow(). This method will try to shut down all running tasks immediately and skip all tasks that have been submitted but not yet run. However, there is no guarantee that the running tasks can be successfully shut down. It is possible that they will be shut down, or they may continue to run until the task is completed. This is a last resort attempt.