ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

fixedThreadPool.execute(new Runnable() {
    public void run() {
        // 执行任务
    }
});
cachedThreadPool.execute(new Runnable() {
    public void run() {
        // 执行任务
    }
});
scheduledThreadPool.schedule(new Runnable() {
    public void run() {
        // 执行任务
    }
}， 5， TimeUnit.SECONDS);
singleThreadExecutor.execute(new Runnable() {
    public void run() {
        // 执行任务
    }
});
forkJoinPool.invoke(new RecursiveTask() {
    public Object compute() {
        // 执行任务
    }
});

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
     /*
      * 1.如果当前线程数量小于核心线程数，开启一个新线程，然后把任务作为该线程首个任务来执行
      * 2.如果当前线程数量等于核心线程数，尝试添加任务到阻塞队列BlockingQueue
      * 3.如果添加队列失败，即队列已满，开启一个新线程，然后把任务作为该线程首个任务来执行
      * 4.如果第3步开启线程失败，即线程数量超过最大线程数，调用RejectedExecutionHandler的       *       *   rejectedExecution方法执行拒绝策略。
      */
    //获取线程池状态和线程数量的组合值，这两个值被打包到了一个int中
    int c = ctl.get();
    //workerCountOf 获取Worker的数量，即线程数量。
    //isRunning  获取线程池的状态，判断线程池是否是运行状态
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command，true))
            return;
        //重新获取，多线程环境，该值可能已经发生变化
        c = ctl.get();
    }
    //尝试添加到队列
    if (isRunning(c) && workQueue.offer(command)) {
        //重新检查状态值 如果线程已经shutdown 则拒绝添加任务
        int recheck = ctl.get();
        if (! isRunning(recheck) && remove(command))
            reject(command);
        else if (workerCountOf(recheck) == 0)
            addWorker(null，false);
    }
    //以非核心线程添加模式创建线程，如果失败，走拒绝策略
    else if (!addWorker(command，false))
        reject(command);
}

    override fun run() {
          threadName("OkHttp ${redactedUrl()}") {
            var signalledCallback = false
            //使用AsyncTimeout监听请求是否超时，会开启一个子线程，线程名称 Okio Watchdog    
            //超时后会调用Call的cancel取消请求    
            timeout.enter()
            try {
                //组装过滤器链 开始执行请求流程
              val response = getResponseWithInterceptorChain()
              signalledCallback = true
                //回调请求结果
              responseCallback.onResponse(this@RealCall， response)
            } catch (e: IOException) {
              if (signalledCallback) {
                // Do not signal the callback twice!
                Platform.get().log("Callback failure for ${toLoggableString()}"， Platform.INFO， e)
              } else {
                responseCallback.onFailure(this@RealCall， e)
              }
            } catch (t: Throwable) {
              cancel()
              if (!signalledCallback) {
                val canceledException = IOException("canceled due to $t")
                canceledException.addSuppressed(t)
                responseCallback.onFailure(this@RealCall， canceledException)
              }
              throw t
            } finally {
                //请求执行完成 
              client.dispatcher.finished(this)
            }
          }
        }
      }

    //同时执行的最大请求的数量 
    var maxRequests = 64
    //每个域名可以同时执行的最大请求数量
    var maxRequestsPerHost = 5
      private var executorServiceOrNull: ExecutorService? = null
    //线程池默认使用缓存线程池 
      @get:Synchronized
      @get:JvmName("executorService") val executorService: ExecutorService
        get() {
          if (executorServiceOrNull == null) {
            executorServiceOrNull = ThreadPoolExecutor(0， Int.MAX_VALUE， 60， TimeUnit.SECONDS，
                SynchronousQueue()， threadFactory("$okHttpName Dispatcher"， false))
          }
          return executorServiceOrNull!!
        }
     /** 调用enqueue提交给Dispatcher的请求，还没有提交到线程池执行 */
      private val readyAsyncCalls = ArrayDeque<AsyncCall>()
      /** 提交到线程池正在执行的异步请求，还没有执行完 */
      private val runningAsyncCalls = ArrayDeque<AsyncCall>()
      /** Running synchronous calls. Includes canceled calls that haven't finished yet. */
      private val runningSyncCalls = ArrayDeque<RealCall>()
      constructor(executorService: ExecutorService) : this() {
        this.executorServiceOrNull = executorService
      }

    internal fun enqueue(call: AsyncCall) {
      synchronized(this) {
        //1.添加到待执行队列  
        readyAsyncCalls.add(call)
        // Mutate the AsyncCall so that it shares the AtomicInteger of an existing running call to
        // the same host.
        if (!call.call.forWebSocket) {
            //2.不是webSocket请求 从待执行异步队列和已执行异步队列中查找相同host的请求
            //把已经存在的call的callsPerHost拷贝到新call的callsPerHost
          val existingCall = findExistingCallWithHost(call.host)
          if (existingCall != null) call.reuseCallsPerHostFrom(existingCall)
        }
      }
        //3.提交给线程池执行
      promoteAndExecute()
    }

private fun promoteAndExecute(): Boolean {
  this.assertThreadDoesntHoldLock()
  val executableCalls = mutableListOf<AsyncCall>()
  val isRunning: Boolean
  synchronized(this) {
      //1.遍历带执行队列
    val i = readyAsyncCalls.iterator()
    while (i.hasNext()) {
      val asyncCall = i.next()
      //正在执行的请求数量大于64 直接退出循环
      if (runningAsyncCalls.size >= this.maxRequests) break // Max capacity.
      //单个域名的最大请求数量大于5 处理下一个请求    
      if (asyncCall.callsPerHost.get() >= this.maxRequestsPerHost) continue // Host max capacity.
      //将请求从待执行队列移除 添加到已执行队列中 
      i.remove()
      //增加相同域名的请求数量    
      asyncCall.callsPerHost.incrementAndGet()
      //添加到 临时的可执行队列     
      executableCalls.add(asyncCall)
      runningAsyncCalls.add(asyncCall)
    }
    isRunning = runningCallsCount() > 0
  }
  //遍历可执行队列 提交给线程池执行
  for (i in 0 until executableCalls.size) {
    val asyncCall = executableCalls[i]
    asyncCall.executeOn(executorService)
  }
  //isRunning是同步已执行请求和异步已执行请求的任务总量 isRunning>0说明有任务在执行 =0说明没有任务在执行
  return isRunning
}

constructor() : this(5， 5， TimeUnit.MINUTES)
/** Returns the number of idle connections in the pool. */
fun idleConnectionCount(): Int = delegate.idleConnectionCount()
/** Returns total number of connections in the pool. */
fun connectionCount(): Int = delegate.connectionCount()
/** Close and remove all idle connections in the pool. */
//清除和关闭连接池中的所有连接
fun evictAll() {
  delegate.evictAll()
}
//RealConnectionPool
//连接存活的最长时间 默认是5分钟
private val keepAliveDurationNs: Long = timeUnit.toNanos(keepAliveDuration)
private val cleanupQueue: TaskQueue = taskRunner.newQueue()
//清理连接的任务 TaskRunner中使用一个缓存线程池执行改任务
private val cleanupTask = object : Task("$okHttpName ConnectionPool") {
  override fun runOnce() = cleanup(System.nanoTime())
}
/**
 *  使用cas无锁队列存储RealConnection
 */
private val connections = ConcurrentLinkedQueue<RealConnection>()

public class ThreadLocal<T> {
    private final int threadLocalHashCode = nextHashCode();
    //生成ThreadLocal的hashcode的原子计数器
    private static AtomicInteger nextHashCode =
        new AtomicInteger();
    /**
     * The difference between successively generated hash codes - turns
     * implicit sequential thread-local IDs into near-optimally spread
     * multiplicative hash values for power-of-two-sized tables.
       两个ThreadLocal的hash值的间隔差
     */
    private static final int HASH_INCREMENT = 0x61c88647;
    /**
     * Returns the next hash code.
       hash值 以HASH_INCREMENT累加
     */
    private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }
}    

ThreadLocal.ThreadLocalMap threadLocals = null;
//当创建子线程的时候，子线程可以得到父线程的inheritableThreadLocals
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
//-------------------------------------------------------------

//使用WeakReference监听ThreadLocal是否被回收
static class Entry extends WeakReference<ThreadLocal<?>> {
      /** The value associated with this ThreadLocal. */
      Object value;
      Entry(ThreadLocal<?> k，Object v) {
          super(k);
          value = v;
      }
  }
   //初始化容量 16
   private static final int INITIAL_CAPACITY = 16;
  /**
   * The table，resized as necessary.
   * table.length MUST always be a power of two.
   Entry数组
   */
  private Entry[] table;
  /**
   * The number of entries in the table.
     实际存储的数据量
   */
  private int size = 0;
  /**
   * The next size value at which to resize.
     扩容阈值 默认是size达到容量的2/3时扩容
   */
  private int threshold; // Default to 0

public void set(T value) {
        //获取当前线程引用
        Thread t = Thread.currentThread();
        //获取当前线程的ThreadLocalMap 如果是空的会创建一个
        ThreadLocalMap map = getMap(t);
        if (map != null)
            //设置值
            map.set(this，value);
        else
            createMap(t，value);
    }
    private void set(ThreadLocal<?> key，Object value) {
            // We don't use a fast path as with get() because it is at
            // least as common to use set() to create new entries as
            // it is to replace existing ones，in which case，a fast
            // path would fail more often than not.
            Entry[] tab = table;
            int len = tab.length;
            //1.对hashcode做与运算 确定ThreadLocal在数组中的索引
            int i = key.threadLocalHashCode & (len-1);
            //2.从当前索引开始向后查找，找到key直接赋值返回，否则找到一个Entry为空的位置，记录i
            //用线性探测的方式解决hash冲突的问题
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i，len)]) {
                ThreadLocal<?> k = e.get();
                //key已经存在 直接替换旧值
                if (k == key) {
                    e.value = value;
                    return;
                }
                //key为空 清理对应的value数据 
                if (k == null) {
                    replaceStaleEntry(key，value，i);
                    return;
                }
            }
            //3.创建一个新的Entry
            tab[i] = new Entry(key，value);
            int sz = ++size;
            //4.先清理key为空的Entry 然后判断是否需要扩容
            if (!cleanSomeSlots(i，sz) && sz >= threshold)
                rehash();
        }

public T get() {
    //1.获取当前线程的ThreadLocalMap
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        //获取当前ThreadLocal对应的Entry
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}
//---------------------------------------------
private Entry getEntry(ThreadLocal<?> key) {
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    //2.Entry不为空并且key和当前ThreadLocal相同
    if (e != null && e.get() == key)
        return e;
    else
        //3.可能出现了hash冲突 从i开始向数组后面查找
        return getEntryAfterMiss(key，i，e);
}
//---------------------------------------------
private Entry getEntryAfterMiss(ThreadLocal<?> key，int i，Entry e) {
    Entry[] tab = table;
    int len = tab.length;
    //从i开始循环遍历 当Entry=null的时候 说明后面的肯定都是空的
    while (e != null) {
        ThreadLocal<?> k = e.get();
        if (k == key)
            return e;
        if (k == null)
            expungeStaleEntry(i);
        else
            i = nextIndex(i，len);
        e = tab[i];
    }
    return null;
}

private void resize() {
    Entry[] oldTab = table;
    int oldLen = oldTab.length;
    int newLen = oldLen * 2;
    //扩容速度为原先容量的2倍
    Entry[] newTab = new Entry[newLen];
    int count = 0;
    //把原先的数据拷贝到新数组中
    for (int j = 0; j < oldLen; ++j) {
        Entry e = oldTab[j];
        if (e != null) {
            ThreadLocal<?> k = e.get();
            if (k == null) {
                e.value = null; // Help the GC
            } else {
                //重新计算hash值 解决hash冲突
                int h = k.threadLocalHashCode & (newLen - 1);
                while (newTab[h] != null)
                    h = nextIndex(h，newLen);
                newTab[h] = e;
                count++;
            }
        }
    }
    //重新设置新的扩容阈值 为数组长度的2/3
    setThreshold(newLen);
    size = count;
    table = newTab;
}

    public void start() {
        Project project = null;
        do {
            //1.是否有为当前进程单独配置的Project，此为最高优先级
            if (mProjectForCurrentProcess != null) {
                project = (Project) mProjectForCurrentProcess;
                break;
            }
            //2.如果当前是主进程，是否有配置主进程Project
            if (AlphaUtils.isInMainProcess(mContext)
                    && mProjectArray.indexOfKey(MAIN_PROCESS_MODE) >= 0) {
                project = (Project) mProjectArray.get(MAIN_PROCESS_MODE);
                break;
            }
            //3.如果是非主进程，是否有配置非主进程的Project
            if (!AlphaUtils.isInMainProcess(mContext)
                    && mProjectArray.indexOfKey(SECONDARY_PROCESS_MODE) >= 0) {
                project = (Project) mProjectArray.get(SECONDARY_PROCESS_MODE);
                break;
            }
            //4.是否有配置适用所有进程的Project
            if (mProjectArray.indexOfKey(ALL_PROCESS_MODE) >= 0) {
                project = (Project) mProjectArray.get(ALL_PROCESS_MODE);
                break;
            }
        } while (false);
        if (project != null) {
            addListeners(project);
            project.start();
        } else {
            AlphaLog.e(AlphaLog.GLOBAL_TAG， "No startup project for current process.");
        }
    }

    public void addProject(Task project， int mode) {
        if (project == null) {
            throw new IllegalArgumentException("project is null");
        }
        if (mode < MAIN_PROCESS_MODE || mode > ALL_PROCESS_MODE) {
            throw new IllegalArgumentException("No such mode: " + mode);
        }
        if (AlphaUtils.isMatchMode(mContext， mode)) {
            mProjectArray.put(mode， project);
        }
    }

    @Override
    public void start() {
        mStartTask.start();
    }

        //Project.java
        private void init() {
        ...
            mProject = new Project();
            mFinishTask = new AnchorTask(false， "==AlphaDefaultFinishTask==");
            mFinishTask.setProjectLifecycleCallbacks(mProject);
            mStartTask = new AnchorTask(true， "==AlphaDefaultStartTask==");
            mStartTask.setProjectLifecycleCallbacks(mProject);
            mProject.setStartTask(mStartTask);
            mProject.setFinishTask(mFinishTask);
       ...
        }
    private static class AnchorTask extends Task {
        private boolean mIsStartTask = true;
        private OnProjectExecuteListener mExecuteListener;
        public AnchorTask(boolean isStartTask， String name) {
            super(name);
            mIsStartTask = isStartTask;
        }
        public void setProjectLifecycleCallbacks(OnProjectExecuteListener callbacks) {
            mExecuteListener = callbacks;
        }
        @Override
        public void run() {
            if (mExecuteListener != null) {
                if (mIsStartTask) {
                    mExecuteListener.onProjectStart();
                } else {
                    mExecuteListener.onProjectFinish();
                }
            }
        }
    }        

    public synchronized void start() {
        ...
        switchState(STATE_WAIT);
        if (mInternalRunnable == null) {
            mInternalRunnable = new Runnable() {
                @Override
                public void run() {
                    android.os.Process.setThreadPriority(mThreadPriority);
                    long startTime = System.currentTimeMillis();
                    switchState(STATE_RUNNING);
                    Task.this.run();
                    switchState(STATE_FINISHED);
                    long finishTime = System.currentTimeMillis();
                    recordTime((finishTime - startTime));
                    notifyFinished();
                    recycle();
                }
            };
        }
        if (mIsInUiThread) {
            sHandler.post(mInternalRunnable);
        } else {
            sExecutor.execute(mInternalRunnable);
        }
    }

    void notifyFinished() {
        if (!mSuccessorList.isEmpty()) {
            AlphaUtils.sort(mSuccessorList);
            for (Task task : mSuccessorList) {
                task.onPredecessorFinished(this);
            }
        }
        if (!mTaskFinishListeners.isEmpty()) {
            for (OnTaskFinishListener listener : mTaskFinishListeners) {
                listener.onTaskFinish(mName);
            }
            mTaskFinishListeners.clear();
        }
    }

    //1、紧后任务添加
    public Builder after(Task task) {
        task.addSuccessor(mCacheTask);
        mFinishTask.removePredecessor(task);
        mIsSetPosition = true;
        return Builder.this;
    }
    void addSuccessor(Task task) {
        task.addPredecessor(this);
        mSuccessorList.add(task);
    }
    //2、紧后任务列表排序 
    public static void sort(List<Task> tasks) {
        if (tasks.size() <= 1) {
            return;
        }
        Collections.sort(tasks， sTaskComparator);
    }    
    private static Comparator<Task> sTaskComparator = new Comparator<Task>() {
        @Override
        public int compare(Task lhs， Task rhs) {
            return lhs.getExecutePriority() - rhs.getExecutePriority();
        }
    };    
    //3、紧后任务执行
    synchronized void onPredecessorFinished(Task beforeTask) {
        if (mPredecessorSet.isEmpty()) {
            return;
        }
        mPredecessorSet.remove(beforeTask);
        if (mPredecessorSet.isEmpty()) {
            start();
        }
    }    

public class CustomExecutor extends ThreadPoolExecutor {
    private List<DownLoadTask>  executingTask=new LinkedList<>();
    private volatile  boolean isRunning;
    private ReentrantLock pauseLock=new ReentrantLock();
    private Condition pauseCondition=pauseLock.newCondition();
    public CustomExecutor(int corePoolSize，int maximumPoolSize，long keepAliveTime，TimeUnit unit，BlockingQueue<Runnable> workQueue) {
        super(corePoolSize，maximumPoolSize，keepAliveTime，unit，workQueue);
    }
    public void pause(){
        if (!isRunning){
            return;
        }
        synchronized (this){
            Iterator<DownLoadTask> iterator = executingTask.iterator();
            while (iterator.hasNext()){
                DownLoadTask task = iterator.next();
                task.pause();
            }
            isRunning=false;
        }
    }
    public void resume(){
        if (isRunning){
            return;
        }
        pauseLock.lock();
        try {
            pauseCondition.signalAll();
            Iterator<DownLoadTask> iterator = executingTask.iterator();
            while (iterator.hasNext()){
                DownLoadTask task = iterator.next();
                task.resume();
            }
            isRunning=true;
        } finally {
            pauseLock.unlock();
        }
    }
    @Override
    protected void beforeExecute(Thread t，Runnable r) {
        super.beforeExecute(t，r); 
        pauseLock.lock();
        try {
            while (!isRunning){
                pauseCondition.await();
            }
        } catch (InterruptedException e) {
            t.interrupt();
        } finally {
            pauseLock.unlock();
        }
        synchronized (this){
            if (r instanceof DownLoadTask){
                executingTask.add((DownLoadTask) r);
            }
        }
    }
    @Override
    protected void afterExecute(Runnable r，Throwable t) {
        super.afterExecute(r，t);
        synchronized (this){
            if (r instanceof DownLoadTask){
                executingTask.remove(r);
            }
        }
    }
}

public class ThreadPoolDetector extends Detector implements Detector.JavaScanner {
    public static final Issue ISSUE = Issue.create(
            "创建线程池"，
            "避免自己创建ThreadPool"，
            "请勿直接使用Executors创建线程，建议使用统一的线程池管理工具类"，
            Category.PERFORMANCE，
            6，
            Severity.WARNING，
            new Implementation(ThreadPoolDetector.class， Scope.JAVA_FILE_SCOPE)
    );
    @Override
    public List<Class<? extends Node>> getApplicableNodeTypes() {
        return ImmutableList.of(MethodCall.class);
    }
    @Override
    public void visitMethodCall(@NonNull JavaContext context， @NonNull UCall node， @NonNull PsiMethodCallExpression call) {
        if (node.getMethodName().equals("newFixedThreadPool") || node.getMethodName().equals("newCachedThreadPool") || node.getMethodName().equals("newSingleThreadExecutor")) {
            context.report(ISSUE， node， context.getLocation(node)， "不建议使用Executors创建线程， 改用ThreadPoolExecutor");
        }
    }
}