J.U.C之线程池

先看一下线程池的基础架构图：

  1. Executor
    Executor，任务的执行者，线程池框架中几乎所有类都直接或者间接实现Executor接口，它是线程池框架的基础。Executor提供了一种将“任务提交”与“任务执行”分离开来的机制，它仅提供了一个Execute()方法用来执行已经提交的Runnable任务。

    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，继承Executor，它是“执行者服务”接口，它是为"执行者接口Executor"服务而存在的。准确的地说，ExecutorService提供了“将任务提交给执行者的接口(submit方法)”，“让执行者执行任务(invokeAll, invokeAny方法)”的接口等等。  
    public interface ExecutorService extends Executor {
/**
* 启动一次顺序关闭，执行以前提交的任务，但不接受新任务
*/
void shutdown();

/**
* 试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务列表
*/
List<Runnable> shutdownNow();

/**
* 如果此执行程序已关闭，则返回 true。
*/
boolean isShutdown();

/**
* 如果关闭后所有任务都已完成，则返回 true
*/
boolean isTerminated();

/**
* 请求关闭、发生超时或者当前线程中断，无论哪一个首先发生之后，都将导致阻塞，直到所有任务完成执行
*/
boolean awaitTermination(long timeout, TimeUnit unit)
throws InterruptedException;

/**
* 提交一个返回值的任务用于执行，返回一个表示任务的未决结果的 Future
*/
<T> Future<T> submit(Callable<T> task);

/**
* 提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future
*/
<T> Future<T> submit(Runnable task, T result);

/**
* 提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future
*/
Future<?> submit(Runnable task);

/**
* 执行给定的任务，当所有任务完成时，返回保持任务状态和结果的 Future 列表
*/
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
throws InterruptedException;

/**
* 执行给定的任务，当所有任务完成或超时期满时（无论哪个首先发生），返回保持任务状态和结果的 Future 列表
*/
<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;}
  3. AbstractExecutorService
    抽象类，实现ExecutorService接口，为其提供默认实现。
    AbstractExecutorService除了实现ExecutorService接口外，还提供了newTaskFor()方法返回一个RunnableFuture，在运行的时候，它将调用底层可调用任务，作为 Future 任务，它将生成可调用的结果作为其结果，并为底层任务提供取消操作。
  4. ScheduleExecutorService
    继承ExcutorService，是一个“延迟”和“定期执行”的ExecutorService，提供了一些方法安排任务按照给定的条件延时执行或者周期性执行。 
    // 创建并执行在给定延迟后启用的 ScheduledFuture。
<V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit)

// 创建并执行在给定延迟后启用的一次性操作。
ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)

// 创建并执行一个在给定初始延迟后首次启用的定期操作，后续操作具有给定的周期；
//也就是将在 initialDelay 后开始执行，然后在 initialDelay+period 后执行，接着在 initialDelay + 2 * period 后执行，依此类推。
ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)

// 创建并执行一个在给定初始延迟后首次启用的定期操作，随后，在每一次执行终止和下一次执行开始之间都存在给定的延迟。
ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
  5. ThreadPoolExecutor
    ThreadPoolExecutor是AbstractExecutorService的默认实现，也是Executors工厂类的底层实现，提供了四个重载的自定义线程池参数的构造方法，提供了提交任务和中止线程池的执行方法，也提供了查看线程池运行状态的监控方法。
    ThreadPoolExecutor的具体分析将在另一篇博客具体阐述，在此只简单介绍三个方法：
  6.     //实现Executor的execute方法
    //1.如果线程池当前线程数小于corePoolSize，则调用addWorker创建新线程执行任务，成功返回true，失败执行步骤2
    //2.如果线程池处于RUNNING状态，则尝试加入阻塞队列，如果加入阻塞队列成功，则尝试进行Double Check，确保线程可以被执行，如果加入失败，则执行步骤3
    //3.如果线程池不是RUNNING状态或者加入阻塞队列失败，则尝试创建新线程直到maxPoolSize，如果失败，则调用reject()方法执行对应的拒绝策略
    public void execute(Runnable var1) {
        if (var1 == null) {
            throw new NullPointerException();
        } else {
            int var2 = this.ctl.get();
            if (workerCountOf(var2) < this.corePoolSize) {
                if (this.addWorker(var1, true)) {
                    return;
                }

                var2 = this.ctl.get();
            }

            if (isRunning(var2) && this.workQueue.offer(var1)) {
                int var3 = this.ctl.get();
                if (!isRunning(var3) && this.remove(var1)) {
                    this.reject(var1);
                } else if (workerCountOf(var3) == 0) {
                    this.addWorker((Runnable)null, false);
                }
            } else if (!this.addWorker(var1, false)) {
                this.reject(var1);
            }

        }
    }

    //按过去执行已提交任务的顺序发起一个有序的关闭，但是不接受新任务
    public void shutdown() {
        ...
    }

    //尝试停止所有的活动执行任务、暂停等待任务的处理，并返回等待执行的任务列表
    public List<Runnable> shutdownNow() {
        ...
    }
  7. ScheduledThreadPoolExecutor
    ScheduledThreadPoolExecutor继承ThreadPoolExecutor并且实现ScheduledExecutorService接口，相当于提供了“延迟”和“周期执行”功能的ThreadPoolExecutor。
  8. Executors
    静态工厂类，提供了Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 、Callable 等类的静态工厂方法，通过这些工厂方法我们可以得到相对应的对象。 


    （1）创建并返回设置有常用配置字符串的 ExecutorService 的方法。

    （2）创建并返回设置有常用配置字符串的 ScheduledExecutorService 的方法。

    （3）创建并返回“包装的”ExecutorService 方法，它通过使特定于实现的方法不可访问来禁用重新配置。

    （4）创建并返回 ThreadFactory 的方法，它可将新创建的线程设置为已知的状态。

    （5）创建并返回非闭包形式的 Callable 的方法，这样可将其用于需要 Callable 的执行方法中。

原文地址：https://www.cnblogs.com/CHMaple/p/9283678.html

时间： 2024-11-02 01:55:58

J.U.C之线程池的相关文章

python 之路11 进程池，线程池

1.线程 基本使用 创建线程 import threading # def f1(arg): # print(arg) # # t = threading.Thread(target=f1,args=(123,)) # t.start() # class Mythread(threading.Thread): # def __init__(self,func,arg): # self.func = func # self.arg = arg # super(Mythread,self).__in

[Java Performance] 线程及同步的性能 - 线程池/ThreadPoolExecutors/ForkJoinPool

线程池和ThreadPoolExecutors 虽然在程序中可以直接使用Thread类型来进行线程操作,但是更多的情况是使用线程池,尤其是在Java EE应用服务器中,一般会使用若干个线程池来处理来自客户端的请求.Java中对于线程池的支持,来自ThreadPoolExecutor.一些应用服务器也确实是使用的ThreadPoolExecutor来实现线程池. 对于线程池的性能调优,最重要的参数就是线程池的大小. 对于任何线程池而言,它们的工作方式几乎都是相同的: 任务被投放到一个队列中(队列的

Java并发程序设计(6)线程池之线程数量的控制

1.1. ExecutorService ExecutorService是线程池的接口. Executors是用于创建不同线程池的工具类. 1.2. 线程数量固定的线程池 ExecutorService executorService = Executors.newFixedThreadPool(2); for(int j=0;j<10;j++){ final int t = j; executorService.execute( new Runnable(){ @Override public

C#多线程实现方法——线程池(Thread Pool)

ThreadPool使用 同步机制 ThreadPool使用 需要定义waitcallback委托形式如 [csharp] view plain copy print? public delegate void WaitCallback(object state); public delegate void WaitCallback(object state); 例如如下例子: [csharp] view plain copy print? static private void ThreadW

Java线程池应用

Executors工具类用于创建Java线程池和定时器. newFixedThreadPool:创建一个可重用固定线程数的线程池,以共享的无界队列方式来运行这些线程.在任意点,在大多数 nThreads 线程会处于处理任务的活动状态.如果在所有线程处于活动状态时提交附加任务,则在有可用线程之前,附加任务将在队列中等待.如果在关闭前的执行期间由于失败而导致任何线程终止,那么一个新线程将代替它执行后续的任务(如果需要).在某个线程被显式地关闭之前,池中的线程将一直存在. 创建一个固定大小的线程池来执

深入浅出 Java Concurrency (33): 线程池 part 6 线程池的实现及原理 (1)[转]

线程池数据结构与线程构造方法 由于已经看到了ThreadPoolExecutor的源码,因此很容易就看到了ThreadPoolExecutor线程池的数据结构.图1描述了这种数据结构. 图1 ThreadPoolExecutor 数据结构 其实,即使没有上述图形描述ThreadPoolExecutor的数据结构,我们根据线程池的要求也很能够猜测出其数据结构出来. 线程池需要支持多个线程并发执行,因此有一个线程集合Collection<Thread>来执行线程任务: 涉及任务的异步执行,因此需要

Android线程池中的任务取消

============问题描述============ ExecutorService pool = Executors.newFixedThreadPool(2); //创建实现了Runnable接口对象,Thread对象当然也实现了Runnable接口 Thread t1 = new MyThread(); Thread t2 = new MyThread(); Thread t3 = new MyThread(); Thread t4 = new MyThread(); Thread t

Java并发程序设计(7)线程池之异常终止和正常关闭

1.1. 线程池中的线程的异常终止 如果线程池中的线程的任务代码发生异常导致线程终止,线程池会自动创建一个新线程. 对于各种类型的线程池,都是如此.以下代码在单个线程的线程池中抛出一个异常,可以发现后续任务中输出的每个tid的值都不相同. ExecutorService executorService = Executors.newSingleThreadExecutor(); for(int j=0;j<10;j++){ final int t = j; executorService.exe

Java多线程——Executors和线程池

线程池的概念与Executors类的应用 1.创建固定大小的线程池 package java_thread; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; public class ThreadPoolTest { /** * @param args */ public static void mai