JDK 8 ThreadPoolExecutor源码详解（详细注释版）

本文链接：https://blog.csdn.net/csdn_tom_168/article/details/149651536

JDK 8 ThreadPoolExecutor源码详解（详细注释版）

1. ThreadPoolExecutor核心类源码

/*
 * ThreadPoolExecutor是ExecutorService接口的主要实现类
 * 提供了可配置的线程池实现，支持多种线程池配置和管理策略
 */
public class ThreadPoolExecutor extends AbstractExecutorService {
    
    // 原子整数，用于同时记录线程池状态和工作线程数量
    // 使用Integer的前3位表示状态，后29位表示线程数量
    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    
    // 线程池状态位数：29位用于线程计数，3位用于状态
    private static final int COUNT_BITS = Integer.SIZE - 3; // 29
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1; // 2^29 - 1 = 536870911
    
    // 线程池运行状态定义（按数字大小排序）
    private static final int RUNNING    = -1 << COUNT_BITS; // -536870912，接收新任务并处理队列
    private static final int SHUTDOWN   =  0 << COUNT_BITS; // 0，不接收新任务但处理队列
    private static final int STOP       =  1 << COUNT_BITS; // 536870912，不接收新任务不处理队列并中断运行任务
    private static final int TIDYING    =  2 << COUNT_BITS; // 1073741824，所有任务终止，执行terminated()
    private static final int TERMINATED =  3 << COUNT_BITS; // 1610612736，terminated()执行完成
    
    // 从ctl中提取运行状态（高3位）
    private static int runStateOf(int c)     { return c & ~CAPACITY; }
    
    // 从ctl中提取工作线程数（低29位）
    private static int workerCountOf(int c)  { return c & CAPACITY; }
    
    // 组合运行状态和工作线程数
    private static int ctlOf(int rs, int wc) { return rs | wc; }
    
    // 判断线程池状态是否至少为给定状态
    private static boolean runStateAtLeast(int c, int s) {
        return c >= s;
    }
    
    // 判断线程池是否处于运行状态
    private static boolean isRunning(int c) {
        return c < SHUTDOWN;
    }
    
    // CAS操作增加工作线程数
    private boolean compareAndIncrementWorkerCount(int expect) {
        return ctl.compareAndSet(expect, expect + 1);
    }
    
    // CAS操作减少工作线程数
    private boolean compareAndDecrementWorkerCount(int expect) {
        return ctl.compareAndSet(expect, expect - 1);
    }
    
    // 减少工作线程数（不使用CAS）
    private void decrementWorkerCount() {
        do {} while (! compareAndDecrementWorkerCount(ctl.get()));
    }
    
    // 主锁，用于保护workers集合和相关计数器
    private final ReentrantLock mainLock = new ReentrantLock();
    
    // 工作线程集合，受mainLock保护
    private final HashSet<Worker> workers = new HashSet<Worker>();
    
    // 终止条件，当线程池完全终止时发出信号
    private final Condition termination = mainLock.newCondition();
    
    // 记录线程池达到的最大线程数
    private int largestPoolSize;
    
    // 已完成的任务总数
    private long completedTaskCount;
    
    // 线程工厂，用于创建新线程
    private volatile ThreadFactory threadFactory;
    
    // 拒绝执行处理器
    private volatile RejectedExecutionHandler handler;
    
    // 空闲线程存活时间（纳秒）
    private volatile long keepAliveTime;
    
    // 是否允许核心线程超时
    private volatile boolean allowCoreThreadTimeOut;
    
    // 核心线程数
    private volatile int corePoolSize;
    
    // 最大线程数
    private volatile int maximumPoolSize;
    
    // 默认拒绝执行处理器
    private static final RejectedExecutionHandler defaultHandler =
        new AbortPolicy();
    
    /**
     * Worker内部类
     * 继承AbstractQueuedSynchronizer并实现Runnable接口
     * 用于包装工作线程，提供锁机制和任务执行
     */
    private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
    {
        private static final long serialVersionUID = 6138294804551838833L;
        
        // 实际的工作线程
        final Thread thread;
        // 第一个要执行的任务（可能为null）
        Runnable firstTask;
        // 完成的任务数
        volatile long completedTasks;
        
        /**
         * 构造方法
         * @param firstTask 第一个要执行的任务
         */
        Worker(Runnable firstTask) {
            // 初始化为-1，防止在runWorker前被中断
            setState(-1); 
            this.firstTask = firstTask;
            // 使用线程工厂创建新线程
            this.thread = getThreadFactory().newThread(this);
        }
        
        /**
         * 实现Runnable接口的run方法
         */
        public void run() {
            runWorker(this);
        }
        
        // 锁相关方法，继承自AQS
        
        // 判断是否被独占
        protected boolean isHeldExclusively() {
            return getState() != 0;
        }
        
        // 尝试获取锁
        protected boolean tryAcquire(int unused) {
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }
        
        // 尝试释放锁
        protected boolean tryRelease(int unused) {
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }
        
        // 公共锁方法
        public void lock()        { acquire(1); }
        public boolean tryLock()  { return tryAcquire(1); }
        public void unlock()      { release(1); }
        public boolean isLocked() { return isHeldExclusively(); }
        
        /**
         * 如果线程已启动，则中断它
         */
        void interruptIfStarted() {
            Thread t;
            if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
                try {
                    t.interrupt();
                } catch (SecurityException ignore) {
                }
            }
        }
    }
    
    /*
     * 线程池主要方法实现
     */
    
    /**
     * 执行给定的命令
     * 这是Executor接口的核心方法
     * 
     * @param command 要执行的命令
     * @throws RejectedExecutionException 如果任务被拒绝执行
     * @throws NullPointerException 如果command为null
     */
    @Override
    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        
        /*
         * 执行流程：
         * 1. 如果工作线程数小于核心线程数，尝试创建新线程执行任务
         * 2. 否则如果线程池处于运行状态且任务队列未满，将任务加入队列
         * 3. 否则如果工作线程数小于最大线程数，创建新线程执行任务
         * 4. 否则拒绝执行任务
         */
        
        int c = ctl.get();
        
        // 情况1：工作线程数小于核心线程数，创建新线程
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        
        // 情况2：线程池运行且任务队列未满，将任务加入队列
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            // 再次检查线程池状态
            if (! isRunning(recheck) && remove(command))
                reject(command);
            // 如果没有工作线程，创建一个非核心线程
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        // 情况3：创建工作线程执行任务
        else if (!addWorker(command, false))
            // 情况4：拒绝执行任务
            reject(command);
    }
    
    /**
     * 添加工作线程的核心方法
     * 
     * @param firstTask 新线程要执行的第一个任务，可能为null
     * @param core 是否为核心线程
     * @return 是否成功添加工作线程
     */
    private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);
            
            // 检查是否可以添加工作线程
            // 如果线程池已关闭且满足特定条件，则不允许添加
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;
                
            for (;;) {
                int wc = workerCountOf(c);
                // 检查线程数是否超过限制
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                // CAS增加工作线程数
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // 重新读取ctl
                if (runStateOf(c) != rs)
                    continue retry; // 状态已改变，重新开始外层循环
            }
        }
        
        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            // 创建Worker对象
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    // 重新检查线程池状态
                    int rs = runStateOf(ctl.get());
                    
                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // 线程不应该已经启动
                            throw new IllegalThreadStateException();
                        // 将Worker添加到工作线程集合
                        workers.add(w);
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    // 启动线程
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }
    
    /**
     * 添加工作线程失败的处理方法
     * 
     * @param w 失败的Worker
     */
    private void addWorkerFailed(Worker w) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            if (w != null)
                workers.remove(w);
            decrementWorkerCount();
            tryTerminate();
        } finally {
            mainLock.unlock();
        }
    }
    
    /**
     * 工作线程退出时的处理方法
     * 
     * @param w 退出的Worker
     * @param completedAbruptly 是否异常退出
     */
    private void processWorkerExit(Worker w, boolean completedAbruptly) {
        if (completedAbruptly) // 如果异常退出，减少工作线程计数
            decrementWorkerCount();
            
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            // 更新完成任务数统计
            completedTaskCount += w.completedTasks;
            // 从工作线程集合中移除
            workers.remove(w);
        } finally {
            mainLock.unlock();
        }
        
        tryTerminate();
        
        int c = ctl.get();
        // 如果不是异常终止
        if (! completedAbruptly) {
            // 计算最小线程数
            int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
            // 如果允许核心线程超时或核心线程数为0，保持至少一个线程
            if (min == 0 && ! workQueue.isEmpty())
                min = 1;
            // 如果当前线程数大于等于最小线程数，直接返回
            if (workerCountOf(c) >= min)
                return; // replacement not needed
        }
        // 添加新的非核心工作线程
        addWorker(null, false);
    }
    
    /**
     * 获取任务的核心方法
     * Worker线程通过此方法从队列中获取任务
     * 
     * @return 获取到的任务，如果应该退出则返回null
     */
    private Runnable getTask() {
        boolean timedOut = false; // 上次获取任务是否超时
        
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);
            
            // 检查是否应该退出
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }
            
            int wc = workerCountOf(c);
            
            // 判断是否需要超时控制
            // 允许核心线程超时或当前线程数超过核心线程数时需要超时控制
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
            
            // 判断是否应该终止线程
            if ((wc > maximumPoolSize || (timed && timedOut)) &&
                (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }
            
            try {
                // 根据是否需要超时控制选择不同的获取方式
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }
    
    /**
     * Worker线程执行任务的核心方法
     * 
     * @param w 执行任务的Worker
     */
    final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // 允许中断
        
        boolean completedAbruptly = true;
        try {
            // 循环获取并执行任务
            while (task != null || (task = getTask()) != null) {
                w.lock();
                // 如果线程池已停止，确保线程被中断
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    // 执行前钩子方法
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        // 执行任务
                        task.run();
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        // 执行后钩子方法
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            // 处理Worker退出
            processWorkerExit(w, completedAbruptly);
        }
    }
    
    /**
     * 拒绝执行任务的方法
     * 
     * @param command 被拒绝的任务
     */
    final void reject(Runnable command) {
        handler.rejectedExecution(command, this);
    }
    
    /**
     * 关闭线程池
     * 不再接受新任务，但会执行已提交的任务
     */
    @Override
    public void shutdown() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            checkShutdownAccess();
            advanceRunState(SHUTDOWN);
            interruptIdleWorkers();
            onShutdown(); // 钩子方法，给ScheduledThreadPoolExecutor使用
        } finally {
            mainLock.unlock();
        }
        tryTerminate();
    }
    
    /**
     * 立即关闭线程池
     * 尝试停止所有正在执行的任务，返回未开始执行的任务列表
     * 
     * @return 未开始执行的任务列表
     */
    @Override
    public List<Runnable> shutdownNow() {
        List<Runnable> tasks;
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            checkShutdownAccess();
            advanceRunState(STOP);
            interruptWorkers();
            tasks = drainQueue();
        } finally {
            mainLock.unlock();
        }
        tryTerminate();
        return tasks;
    }
    
    /**
     * 中断所有工作线程
     */
    private void interruptWorkers() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (Worker w : workers)
                w.interruptIfStarted();
        } finally {
            mainLock.unlock();
        }
    }
    
    /**
     * 中断空闲的工作线程
     */
    private void interruptIdleWorkers() {
        interruptIdleWorkers(false);
    }
    
    /**
     * 中断空闲的工作线程
     * 
     * @param onlyOne 是否只中断一个线程
     */
    private void interruptIdleWorkers(boolean onlyOne) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (Worker w : workers) {
                Thread t = w.thread;
                if (!t.isInterrupted() && w.tryLock()) {
                    try {
                        t.interrupt();
                    } catch (SecurityException ignore) {
                    } finally {
                        w.unlock();
                    }
                }
                if (onlyOne)
                    break;
            }
        } finally {
            mainLock.unlock();
        }
    }
    
    /**
     * 推进运行状态
     * 
     * @param targetState 目标状态
     */
    private void advanceRunState(int targetState) {
        for (;;) {
            int c = ctl.get();
            if (runStateAtLeast(c, targetState) ||
                ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))
                break;
        }
    }
    
    /**
     * 尝试终止线程池
     */
    final void tryTerminate() {
        for (;;) {
            int c = ctl.get();
            // 如果线程池已经在终止过程中或仍处于运行状态，直接返回
            if (isRunning(c) ||
                runStateAtLeast(c, TIDYING) ||
                (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
                return;
                
            // 如果还有工作线程，中断一个空闲线程
            if (workerCountOf(c) != 0) { 
                interruptIdleWorkers(ONLY_ONE);
                return;
            }
            
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                // CAS设置状态为TIDYING
                if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
                    try {
                        terminated();
                    } finally {
                        // 设置状态为TERMINATED
                        ctl.set(ctlOf(TERMINATED, 0));
                        termination.signalAll();
                    }
                    return;
                }
            } finally {
                mainLock.unlock();
            }
            // else retry on failed CAS
        }
    }
    
    /**
     * 钩子方法，在线程池完全终止时调用
     */
    protected void terminated() { }
    
    /**
     * 等待线程池终止
     */
    @Override
    public boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException {
        long nanos = unit.toNanos(timeout);
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (;;) {
                if (runStateAtLeast(ctl.get(), TERMINATED))
                    return true;
                if (nanos <= 0)
                    return false;
                nanos = termination.awaitNanos(nanos);
            }
        } finally {
            mainLock.unlock();
        }
    }
    
    // 各种getter和setter方法...
    
    /**
     * 设置核心线程数
     */
    public void setCorePoolSize(int corePoolSize) {
        if (corePoolSize < 0)
            throw new IllegalArgumentException();
        int delta = corePoolSize - this.corePoolSize;
        this.corePoolSize = corePoolSize;
        if (workerCountOf(ctl.get()) > corePoolSize)
            interruptIdleWorkers();
        else if (delta > 0) {
            // 我们不需要替换核心线程
            int k = Math.min(delta, workQueue.size());
            while (k-- > 0 && addWorker(null, true)) {
                if (workQueue.isEmpty())
                    break;
            }
        }
    }
    
    /**
     * 获取核心线程数
     */
    public int getCorePoolSize() {
        return corePoolSize;
    }
    
    /**
     * 设置最大线程数
     */
    public void setMaximumPoolSize(int maximumPoolSize) {
        if (maximumPoolSize <= 0 || maximumPoolSize < corePoolSize)
            throw new IllegalArgumentException();
        this.maximumPoolSize = maximumPoolSize;
        if (workerCountOf(ctl.get()) > maximumPoolSize)
            interruptIdleWorkers();
    }
    
    /**
     * 获取最大线程数
     */
    public int getMaximumPoolSize() {
        return maximumPoolSize;
    }
    
    /**
     * 设置线程空闲时间
     */
    public void setKeepAliveTime(long time, TimeUnit unit) {
        if (time < 0)
            throw new IllegalArgumentException();
        if (time == 0 && allowsCoreThreadTimeOut())
            throw new IllegalArgumentException();
        long keepAliveTime = unit.toNanos(time);
        this.keepAliveTime = keepAliveTime;
        if (time > 0)
            interruptIdleWorkers();
    }
    
    /**
     * 获取线程空闲时间
     */
    public long getKeepAliveTime(TimeUnit unit) {
        return unit.convert(keepAliveTime, TimeUnit.NANOSECONDS);
    }
    
    /**
     * 设置是否允许核心线程超时
     */
    public void allowCoreThreadTimeOut(boolean value) {
        if (value && keepAliveTime <= 0)
            throw new IllegalArgumentException();
        if (value != allowCoreThreadTimeOut) {
            allowCoreThreadTimeOut = value;
            if (value)
                interruptIdleWorkers();
        }
    }
    
    /**
     * 判断是否允许核心线程超时
     */
    public boolean allowsCoreThreadTimeOut() {
        return allowCoreThreadTimeOut;
    }
    
    /**
     * 获取线程池大小
     */
    public int getPoolSize() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            // Remove rare and surprising possibility of
            // isTerminated() && getPoolSize() > 0
            return runStateAtLeast(ctl.get(), TIDYING) ? 0
                : workers.size();
        } finally {
            mainLock.unlock();
        }
    }
    
    /**
     * 获取活跃线程数
     */
    public int getActiveCount() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            int n = 0;
            for (Worker w : workers)
                if (w.isLocked())
                    ++n;
            return n;
        } finally {
            mainLock.unlock();
        }
    }
    
    /**
     * 获取已完成任务数
     */
    public long getCompletedTaskCount() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            long n = completedTaskCount;
            for (Worker w : workers)
                n += w.completedTasks;
            return n;
        } finally {
            mainLock.unlock();
        }
    }
    
    /**
     * 获取任务队列
     */
    public BlockingQueue<Runnable> getQueue() {
        return workQueue;
    }
    
    /**
     * 从队列中移除任务
     */
    public boolean remove(Runnable task) {
        boolean removed = workQueue.remove(task);
        tryTerminate(); // In case SHUTDOWN and now empty
        return removed;
    }
    
    /**
     * 预启动所有核心线程
     */
    public int prestartAllCoreThreads() {
        int n = 0;
        while (addWorker(null, true))
            ++n;
        return n;
    }
    
    /**
     * 预启动核心线程
     */
    public boolean prestartCoreThread() {
        return workerCountOf(ctl.get()) < corePoolSize &&
            addWorker(null, true);
    }
}

2. 拒绝策略实现

/**
 * 直接抛出RejectedExecutionException异常
 */
public static class AbortPolicy implements RejectedExecutionHandler {
    public AbortPolicy() { }
    
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        throw new RejectedExecutionException("Task " + r.toString() +
            " rejected from " +
            e.toString());
    }
}

/**
 * 在调用者线程中直接执行任务
 */
public static class CallerRunsPolicy implements RejectedExecutionHandler {
    public CallerRunsPolicy() { }
    
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            r.run();
        }
    }
}

/**
 * 默默丢弃任务
 */
public static class DiscardPolicy implements RejectedExecutionHandler {
    public DiscardPolicy() { }
    
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        // 什么都不做，默默丢弃任务
    }
}

/**
 * 丢弃队列中最老的任务，然后尝试重新提交当前任务
 */
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
    public DiscardOldestPolicy() { }
    
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            e.getQueue().poll(); // 丢弃最老的任务
            e.execute(r); // 重新尝试执行当前任务
        }
    }
}

3. 构造方法详解

/**
 * ThreadPoolExecutor的完整构造方法
 * 
 * @param corePoolSize 核心线程数
 * @param maximumPoolSize 最大线程数
 * @param keepAliveTime 空闲线程存活时间
 * @param unit 时间单位
 * @param workQueue 工作队列
 * @param threadFactory 线程工厂
 * @param handler 拒绝策略
 */
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
    if (corePoolSize < 0 ||
        maximumPoolSize <= 0 ||
        maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
        throw new IllegalArgumentException();
    if (workQueue == null || threadFactory == null || handler == null)
        throw new NullPointerException();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}