Java线程池相关类-Executor框架

1.Executor

接口源码：

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 <tt>Executor</tt> 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);

}

接口使用：

public class T01_MyExecutor implements Executor {

    public static void main(String[] args) {

        new T01_MyExecutor().execute(()->System.out.println("hello executor"));

    }

    @Override

    public void execute(Runnable command) {

        //new Thread(command).run();

        command.run();

    }

}

2.ExecutorService

源码：

认识submit方法，扩展了execute方法，具有一个返回值

<T> Future<T> submit(Callable<T> task);

<T> Future<T> submit(Runnable task, T result);

Future<?> submit(Runnable task);

使用：

ExecutorService提供了管理Eecutor生命周期的方法，ExecutorService的生命周期包括了：运行关闭和终止三种状态。

ExecutorService在初始化创建时处于运行状态。

shutdown方法等待提交的任务执行完成并不再接受新任务，在完成全部提交的任务后关闭

shutdownNow方法将强制终止所有运行中的任务并不再允许提交新任务

可以将一个Runnable或Callable提交给ExecutorService的submit方法执行，最终返回一上Futire用来获得任务的执行结果或取消任务

（任务执行完成后并返回执行结果）

public class CallableAndFuture {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        ExecutorService executor = Executors.newSingleThreadExecutor();

        Future<String> future = executor.submit(new Callable<String>() {   //接受一上callable实例

            public String call() throws Exception {

                return "MOBIN";

            }

        });

        System.out.println("任务的执行结果："+future.get());

    }

}

输出：

任务的执行结果：MOBIN

3.Executors

提供了一系列静态工厂方法用于创建各种线程池

newFixedThreadPool:创建可重用且固定线程数的线程池，如果线程池中的所有线程都处于活动状态，此时再提交任务就在队列中等待，直到有可用线程；如果线程池中的某个线程由于异常而结束时，线程池就会再补充一条新线程。

ScheduledExecutorService executor = Executors.newScheduledThreadPool();

4.ThreadPool

线程池的概念

public static void main(String[] args) throws InterruptedException {

        ExecutorService service = Executors.newFixedThreadPool(); //execute submit

        for (int i = ; i < ; i++) {

            service.execute(() -> {

                try {

                    TimeUnit.MILLISECONDS.sleep();

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

                System.out.println(Thread.currentThread().getName());

            });

        }

        System.out.println(service);

        service.shutdown();

        System.out.println(service.isTerminated());

        System.out.println(service.isShutdown());

        System.out.println(service);

        TimeUnit.SECONDS.sleep();

        System.out.println(service.isTerminated());

        System.out.println(service.isShutdown());

        System.out.println(service);

    }

5.Future

public static void main(String[] args) throws InterruptedException, ExecutionException {

        FutureTask<Integer> task = new FutureTask<>(()->{

            TimeUnit.MILLISECONDS.sleep();

            return ;

        }); //new Callable () { Integer call();}

        new Thread(task).start();

        System.out.println(task.get()); //阻塞

        //*******************************

        ExecutorService service = Executors.newFixedThreadPool();

        Future<Integer> f = service.submit(()->{

            TimeUnit.MILLISECONDS.sleep();

            return ;

        });

        System.out.println(f.get());

        System.out.println(f.isDone());

    }

巴特西

Java线程池相关类-Executor框架

最新文章

热门文章