The following editor will bring you a brief talk about the submit method of ThreadPoolExecutor thread pool. The editor thinks it is quite good, so I will share it with you now and give it as a reference for everyone. Let’s follow the editor and take a look.
##jdk1.7.0_79
In the previous article "ThreadPoolExecutor thread pool principle and its execute method", the principle of the thread pool ThreadPoolExecutor and its execute method were mentioned. This article analyzes ThreadPoolExecutor#submit.
For the execution of a task, sometimes we don’t need it to return results, but there are times when we need its return execution results. For a thread, if it does not need to return a result, it can implement Runnable, and if it needs to execute the result, it can implement Callable. In the thread pool, execute also provides a task execution that does not need to return results, and for those that need to return results, its submit method can be called.Review the inheritance relationship of ThreadPoolExecutor.
Only the execute method is defined in the Executor interface, while the submit method is defined in the ExecutorService interface.//ExecutorService public interface ExecutorService extends Executor { ...Future submit(Callable task); Future submit(Runnable task, T result); Future submit(Runnable task); ... }
//AbstractExecutorService public abstract class AbstractExecutorService implements ExecutorService { ... publicFuture submit(Callable task) { if (task == null) throw new NullPointerException(); RunnableFuture ftask = newTaskFor(task); execute(ftask); return ftask; } public Future submit(Runnable task, T result) { if (task == null) throw new NullPointerException(); RunnableFuture ftask = newTaskFor(task); execute(ftask); return ftask; } public Future> submit(Runnable task) { if (task == null) throw new NullPointerExeption(); RunnableFuture ftask = newTaskFor(task, null); execute(ftask); return ftask; } ... }
Below are three examples to get a feel for the submit method.
submit(Callablepackage com.threadpoolexecutor; import java.util.concurrent.*; /** * ThreadPoolExecutor#sumit(Callabletask) * Created by yulinfeng on 6/17/17. */ public class Sumit1 { public static void main(String[] args) throws ExecutionException, InterruptedException { Callable callable = new Callable () { public String call() throws Exception { System.out.println("This is ThreadPoolExetor#submit(Callable task) method."); return "result"; } }; ExecutorService executor = Executors.newSingleThreadExecutor(); Future future = executor.submit(callable); System.out.println(future.get()); } }
submit(Runnable task, T result)
package com.threadpoolexecutor; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; /** * ThreadPoolExecutor#submit(Runnable task, T result) * Created by yulinfeng on 6/17/17. */ public class Submit2 { public static void main(String[] args) throws ExecutionException, InterruptedException { ExecutorService executor = Executors.newSingleThreadExecutor(); Data data = new Data(); Future future = executor.submit(new Task(data), data); System.out.println(future.get().getName()); } } class Data { String name; public String getName() { return name; } public void setName(String name) { this.name = name; } } class Task implements Runnable { Data data; public Task(Data data) { this.data = data; } public void run() { System.out.println("This is ThreadPoolExetor#submit(Runnable task, T result) method."); data.setName("kevin"); } }
submit(Runnable task)
package com.threadpoolexecutor; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; /** * ThreadPoolExecutor#sumit(Runnable runnables) * Created by yulinfeng on 6/17/17. */ public class Submit { public static void main(String[] args) throws ExecutionException, InterruptedException { Runnable runnable = new Runnable() { public void run() { System.out.println("This is ThreadPoolExetor#submit(Runnable runnable) method."); } }; ExecutorService executor = Executors.newSingleThreadExecutor(); Future future = executor.submit(runnable); System.out.println(future.get()); } }
Object, T, and ?, please refer to "Object, T (generic), and ? Difference in Java").
As you can see from the source code above, these three methods are almost the same. The key lies in:RunnableFutureftask = newTaskFor(task); execute(ftask);
//AbstractExecutorService#newTaskFor protectedRunnableFuture newTaskFor(Callable callable) { return new FutureTask (callable); } protected RunnableFuture newTaskFor(Runnable runnable, T value) { return new FutureTask (runnable, value); }
The Future Mode in Java".
The above is the detailed content of Detailed explanation of the submit method of ThreadPoolExecutor thread pool in JAVA. For more information, please follow other related articles on the PHP Chinese website!