Java 1.7 ThreadPoolExecutor源码解析

相比1.6，1.7有些变化：

1、        增加了一个TIDYING状态，这个状态是介于STOP和TERMINATED之间的，如果执行完terminated钩子函数后状态就变成TERMINATED了；

2、        内部类Worker继承了AQS类作为一个独享锁，在运行每个任务前会获取自己的锁；

3、        runState和poolSize两个字段被合并成一个原子字段ctl了，不再使用mainLock保护了。

原文转载：http://blog.csdn.net/yuenkin/article/details/51040001

一、成员变量介绍

[java] view plain copy

  1. public class ThreadPoolExecutor extends AbstractExecutorService {
  2. /**
  3. * ctl字段其实表示两个含义：runState和workerCount(近似1.6中的poolSize)
  4. * int类型，高3位表示runState，低29位表示workerCount。目前这个版本也就限
  5. * 制了线程个数不会超过2^29-1。
  6. * RUNNING: 能接受新的任务且能处理队列里的请求
  7. * SHUTDOWN: 不能接受新的任务但是能处理队列里的请求
  8. * STOP: 不能接受新的任务、不能处理队列里的请求，workers会被interrupt
  9. * TIDYING: 所有的线程都已经terminated了，正准备调用terminated()方法
  10. * TERMININATED: terminated()方法已经调用结束了
  11. *
  12. * RUNNING->SHUTDOWN: 调用shutdown方法
  13. * (RUNNING/SHUTDOWN)>STOP: 调用shutdownNow方法
  14. * SHUTDOWN->TIDYING: 当workers和queue都空的时候
  15. * STOP->TIDYING: 当workers为空的时候
  16. * TIDYING->TERMINATED: 当terminated方法调用结束的时候。
  17. * awaitTermination()直到状态为TERMINATED时才会返回。
  18. *
  19. */
  20. private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
  21. private static final int COUNT_BITS = Integer.SIZE - 3;
  22. private static final int CAPACITY   = (1 << COUNT_BITS) - 1;
  23. // runState is stored in the high-order bits
  24. private static final int RUNNING    = -1 << COUNT_BITS;
  25. private static final int SHUTDOWN   =  0 << COUNT_BITS;
  26. private static final int STOP       =  1 << COUNT_BITS;
  27. private static final int TIDYING    =  2 << COUNT_BITS;
  28. private static final int TERMINATED =  3 << COUNT_BITS;
  29. // 取ctl的高三位，获取runState(运行状态)
  30. private static int runStateOf(int c)     { return c & ~CAPACITY; }
  31. // 取ctl的低29位，获取workerCount(worker的数量)
  32. private static int workerCountOf(int c)  { return c & CAPACITY; }
  33. // 把runState和workerCount合并成ctl，上面两个函数的反操作
  34. private static int ctlOf(int rs, int wc) { return rs | wc; }

二、execute函数

[java] view plain copy

  1. public void execute(Runnable command) {
  2. if (command == null)
  3. throw new NullPointerException();
  4. /*
  5. * 三步走：
  6. * 1. 如果RUNNING的线程数目小于corePoolSize，直接调用addWorker方法
  7. * 启动一个新线程。addWorker函数会检查runState和workerCount，如果不
  8. * 需要新建一个thread就会返回false了
  9. *
  10. * 2. 如果任务被成功的放入了workQueue，我们仍然需要做个double-check
  11. * 因为调用完isRunning(c)后池中的线程可能都退出了或者线程池被shut
  12. * down了。重新检查状态看是要remove掉新来的任务还是创建一个新线程来执
  13. * 行(如果没有活动的线程了)
  14. *
  15. * 3. 如果放入workQueue失败了，我们尝试创建一个新worker。如果失败了，
  16. * 说明线程池被关闭了或者饱和了(超过最大值了)，就直接拒了。
  17. *
  18. */
  19. int c = ctl.get();
  20. if (workerCountOf(c) < corePoolSize) {
  21. // addWorker有可能会失败，失败后重新获取状态并继续往下走
  22. if (addWorker(command, true))
  23. return;
  24. c = ctl.get();
  25. }
  26. if (isRunning(c) && workQueue.offer(command)) {
  27. int recheck = ctl.get();
  28. // 如果isRunning(c)&&workQueue.offer中间并发发生了shutdown，需要remove
  29. // 掉刚放入workQueue的command任务。注意:此时如果有一个worker刚执行完一个task
  30. // 然后从workQueue获取下一个task时，这里的remove就会失败了。
  31. if (! isRunning(recheck) && remove(command))
  32. reject(command);
  33. // 如果是RUNNING状态但是没有可工作的线程，需要直接new一个
  34. else if (workerCountOf(recheck) == 0)
  35. addWorker(null, false);
  36. }
  37. else if (!addWorker(command, false))
  38. reject(command);
  39. }

execute函数大体思路和1.6一致，就三种情况：

①          当前线程池中线程数目小于corePoolSize，直接new一个thread；

②          当先线程池数据大于corePoolSize，则放入workQueue中；

③          如果workQueue满了且线程池中线程数小于maximumPoolSize，则new一个thread。

[java] view plain copy

  1. private boolean addWorker(Runnable firstTask, boolean core) {
  2. retry:
  3. for (;;) {
  4. int c = ctl.get();
  5. int rs = runStateOf(c);
  6. // 如果被shutdown了，一般就直接返回false。但是需要排除一个特例情况：当线程池状
  7. // 态是shutdown，但workQueue不空且workers空了,会调用addWorker(null,false)
  8. // 方法创建一个线程处理workQueue里的任务,这时不能直接返回false。
  9. if (rs >= SHUTDOWN &&
  10. ! (rs == SHUTDOWN &&
  11. firstTask == null &&
  12. ! workQueue.isEmpty()))
  13. return false;
  14. for (;;) {
  15. int wc = workerCountOf(c);
  16. // 如果当前workers数目大于CAPACITY或者大于用户设置了，直接返回false
  17. if (wc >= CAPACITY ||
  18. wc >= (core ? corePoolSize : maximumPoolSize))
  19. return false;
  20. if (compareAndIncrementWorkerCount(c))
  21. break retry;
  22. c = ctl.get();  // Re-read ctl
  23. // 如果仅仅是workerCount变化了，那么继续内层的循环；如果连runState也变化了，
  24. // 则要重新继续外层的循环。
  25. if (runStateOf(c) != rs)
  26. continue retry;
  27. }
  28. }
  29. boolean workerStarted = false;
  30. boolean workerAdded = false;
  31. Worker w = null;
  32. try {
  33. final ReentrantLock mainLock = this.mainLock;
  34. w = new Worker(firstTask);
  35. final Thread t = w.thread;
  36. if (t != null) {
  37. mainLock.lock();
  38. try {
  39. // Recheck while holding lock.
  40. // Back out on ThreadFactory failure or if
  41. // shut down before lock acquired.
  42. int c = ctl.get();
  43. int rs = runStateOf(c);
  44. // 再次检查runState的状态，如果是RUNNING或者SHUTDOWN但是firstTask不空，则
  45. // 把new出来的worker放入workers中。
  46. if (rs < SHUTDOWN ||
  47. (rs == SHUTDOWN && firstTask == null)) {
  48. if (t.isAlive()) // precheck that t is startable
  49. throw new IllegalThreadStateException();
  50. workers.add(w);
  51. int s = workers.size();
  52. if (s > largestPoolSize)
  53. largestPoolSize = s;
  54. workerAdded = true;
  55. }
  56. } finally {
  57. mainLock.unlock();
  58. }
  59. if (workerAdded) {
  60. // 创建worker成功后直接启动线程了
  61. t.start();
  62. workerStarted = true;
  63. }
  64. }
  65. } finally {
  66. if (! workerStarted)
  67. // 创建失败要做清理操作
  68. addWorkerFailed(w);
  69. }
  70. return workerStarted;
  71. }

addWorker函数尝试新建一个thread来运行传递给它的task。当线程池被STOP或SHUTDOWN或threadFactory返 回null时或者OOM时，会返回false并做相应的清理。整个过程分为两步：1、尝试设置workerCount，成功了就到步骤2；2、尝试创建一 个worker并加入到workers里。

[java] view plain copy

  1. private void addWorkerFailed(Worker w) {
  2. final ReentrantLock mainLock = this.mainLock;
  3. mainLock.lock();
  4. try {
  5. if (w != null)
  6. workers.remove(w);
  7. decrementWorkerCount();
  8. tryTerminate();
  9. } finally {
  10. mainLock.unlock();
  11. }
  12. }

addWorkerFailed函数做些清理操作：1、把创建的worker从workers中删除；2、把workerCount减1；3、检查是否可以terminated线程池，防止这个worker的存在导致执行awaitTermination操作的客户端线程阻塞了。

[java] view plain copy

  1. final void tryTerminate() {
  2. for (;;) {
  3. int c = ctl.get();
  4. // 如果是以下三种情况直接返回：
  5. // 1.RUNNING状态; 2.runState>=TIDYING，说明有其他线程执行了tryTerminate操
  6. // 作; 3.SHUTDOWN状态且workQueue不空
  7. if (isRunning(c) ||
  8. runStateAtLeast(c, TIDYING) ||
  9. (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
  10. return;
  11. // 如果workerCount大于0，则中断一个空闲的worker,就返回了。为啥只中断一个呢？
  12. // 因为worker线程退出时也会调用tryTerminate方法(一个接一个的传播)
  13. if (workerCountOf(c) != 0) { // Eligible to terminate
  14. interruptIdleWorkers(ONLY_ONE);
  15. return;
  16. }
  17. final ReentrantLock mainLock = this.mainLock;
  18. mainLock.lock();
  19. try {
  20. // 走到这里说明workers数量为0了，尝试把线程池状态改成TIDYING并调用terminated
  21. // 函数->状态再设置成TERMINATED。如果设置TIDYING失败，则继续循环。
  22. if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
  23. try {
  24. terminated();
  25. } finally {
  26. // terminated函数抛异常也需要执行下面的操作。
  27. ctl.set(ctlOf(TERMINATED, 0));
  28. termination.signalAll();
  29. }
  30. return;
  31. }
  32. } finally {
  33. mainLock.unlock();
  34. }
  35. // else retry on failed CAS
  36. }
  37. }

tryTerminate函数尝试TERMINATED线程 池（当a、SHUTDOWN且queue和pool都空；b、STOP且queue为空了）。如果workers不为0，则中断任意一个空闲的 worker后直接返回。否则：首先，将线程池状态改成TIDYING；其次，调用用户的钩子函数terminated;最后，将状态设置成 TERMINATED。

[java] view plain copy

  1. private void interruptIdleWorkers(boolean onlyOne) {
  2. final ReentrantLock mainLock = this.mainLock;
  3. mainLock.lock();
  4. try {
  5. for (Worker w : workers) {
  6. Thread t = w.thread;
  7. // 如果tryLock成功，就说明这个worker是空闲的。
  8. if (!t.isInterrupted() && w.tryLock()) {
  9. try {
  10. t.interrupt();
  11. } catch (SecurityException ignore) {
  12. } finally {
  13. w.unlock();
  14. }
  15. }
  16. if (onlyOne)
  17. // 如果只中断一个就break，只有tryTerminate函数中使用到这种情况。
  18. break;
  19. }
  20. } finally {
  21. mainLock.unlock();
  22. }
  23. }

interruptIdleWorkers函数根据onlyOne参数决定中断一个或所有空闲的workers(这些workers都阻塞在getTask方法中)。

三、shutdown函数

[java] view plain copy

  1. public void shutdown() {
  2. final ReentrantLock mainLock = this.mainLock;
  3. mainLock.lock();
  4. try {
  5. // 检查调用者是否有权限执行shutdown
  6. checkShutdownAccess();
  7. // 将线程池的状态改成SHUTDOWN
  8. advanceRunState(SHUTDOWN);
  9. // 中断所有空闲的workers
  10. interruptIdleWorkers();
  11. onShutdown(); // hook for ScheduledThreadPoolExecutor
  12. } finally {
  13. mainLock.unlock();
  14. }
  15. // 尝试终止线程池
  16. tryTerminate();
  17. }

shutdown函数就执行几步：把状态改成SHUTDOWN，中断所有空闲的workers，调用onShutdown钩子函数，最后调用tryTerminate尝试终止线程池。

[java] view plain copy

  1. private void advanceRunState(int targetState) {
  2. for (;;) {
  3. int c = ctl.get();
  4. if (runStateAtLeast(c, targetState) ||
  5. ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))
  6. break;
  7. }
  8. }

advanceRunState函数将线程池的状态改成指定状态值，如果现在状态值比target值大就直接返回。targeState的值是SHUTDOWN或者STOP，不能是TIDYING或者TERMINATED（这两种状态需要调用tryTerminate函数设置）。

四、shutdownNow函数

[java] view plain copy

  1. public List<Runnable> shutdownNow() {
  2. List<Runnable> tasks;
  3. final ReentrantLock mainLock = this.mainLock;
  4. mainLock.lock();
  5. try {
  6. // 检查调用者是否有权限执行关闭
  7. checkShutdownAccess();
  8. // 将线程池的状态改成STOP
  9. advanceRunState(STOP);
  10. // 和shutdown不同，这里中断所有的worker线程
  11. interruptWorkers();
  12. // 删除workQueue里的任务并返回任务列表
  13. tasks = drainQueue();
  14. } finally {
  15. mainLock.unlock();
  16. }
  17. // 尝试终止线程池
  18. tryTerminate();
  19. return tasks;
  20. }

shutdownNow函数会中断所有的worker线程，删除workQueue里的任务，最后尝试终止线程池并返回workQueue里的任务。

[java] view plain copy

  1. private void interruptWorkers() {
  2. final ReentrantLock mainLock = this.mainLock;
  3. mainLock.lock();
  4. try {
  5. // 中断所有的worker线程
  6. for (Worker w : workers)
  7. w.interruptIfStarted();
  8. } finally {
  9. mainLock.unlock();
  10. }
  11. }

[java] view plain copy

  1. private List<Runnable> drainQueue() {
  2. BlockingQueue<Runnable> q = workQueue;
  3. List<Runnable> taskList = new ArrayList<Runnable>();
  4. q.drainTo(taskList);
  5. if (!q.isEmpty()) {
  6. for (Runnable r : q.toArray(new Runnable[0])) {
  7. if (q.remove(r))
  8. taskList.add(r);
  9. }
  10. }
  11. return taskList;
  12. }

五、Worker内部类

[java] view plain copy

  1. private final class Worker
  2. extends AbstractQueuedSynchronizer
  3. implements Runnable
  4. {
  5. /** Thread this worker is running in.  Null if factory fails. */
  6. final Thread thread;
  7. /** Initial task to run.  Possibly null. */
  8. Runnable firstTask;
  9. /** Per-thread task counter */
  10. volatile long completedTasks;
  11. /**
  12. * Creates with given first task and thread from ThreadFactory.
  13. * @param firstTask the first task (null if none)
  14. */
  15. Worker(Runnable firstTask) {
  16. // 初始值为-1，防止worker还没启动就被interrupt了；在start开始时会将状态改成0
  17. setState(-1); // inhibit interrupts until runWorker
  18. this.firstTask = firstTask;
  19. this.thread = getThreadFactory().newThread(this);
  20. }
  21. protected boolean isHeldExclusively() {
  22. return getState() != 0;
  23. }
  24. protected boolean tryAcquire(int unused) {
  25. if (compareAndSetState(0, 1)) {
  26. setExclusiveOwnerThread(Thread.currentThread());
  27. return true;
  28. }
  29. return false;
  30. }
  31. protected boolean tryRelease(int unused) {
  32. setExclusiveOwnerThread(null);
  33. setState(0);
  34. return true;
  35. }
  36. // 参数1没有意义，是独占锁
  37. public void lock()        { acquire(1); }
  38. public boolean tryLock()  { return tryAcquire(1); }
  39. public void unlock()      { release(1); }
  40. public boolean isLocked() { return isHeldExclusively(); }

Worker类主要维护着中断的管理和其他操作(runWorker函数)，继承了AQS类实现了一个不可重入的Lock，在获取到一个任务后，准备执行前首先要获取这个锁。同时，在中断空闲的worker时也要先获取到这个锁。

[java] view plain copy

  1. public void run() {
  2. runWorker(this);
  3. }

[java] view plain copy

  1. final void runWorker(Worker w) {
  2. Thread wt = Thread.currentThread();
  3. // 有时我们不想从workQueue取第一个任务，直接执行刚提交的任务
  4. Runnable task = w.firstTask;
  5. w.firstTask = null;
  6. // 把state设置成0，允许中断
  7. w.unlock(); // allow interrupts
  8. boolean completedAbruptly = true;
  9. try {
  10. // 进入循环了
  11. while (task != null || (task = getTask()) != null) {
  12. w.lock();
  13. // 如果是STOP状态，需要保证线程是被中断了的;
  14. // 如果不是需要清空中断状态,但是需要重新检查下状态防止在清除
  15. // 中断时发生了shutdownNow
  16. if ((runStateAtLeast(ctl.get(), STOP) ||
  17. (Thread.interrupted() &&
  18. runStateAtLeast(ctl.get(), STOP))) &&
  19. !wt.isInterrupted())
  20. wt.interrupt();
  21. try {
  22. // 执行前的钩子函数
  23. beforeExecute(wt, task);
  24. Throwable thrown = null;
  25. try {
  26. task.run();
  27. } catch (RuntimeException x) {
  28. thrown = x; throw x;
  29. } catch (Error x) {
  30. thrown = x; throw x;
  31. } catch (Throwable x) {
  32. thrown = x; throw new Error(x);
  33. } finally {
  34. // 执行后的钩子函数
  35. afterExecute(task, thrown);
  36. }
  37. } finally {
  38. task = null;
  39. w.completedTasks++;
  40. w.unlock();
  41. }
  42. }
  43. completedAbruptly = false;
  44. } finally {
  45. processWorkerExit(w, completedAbruptly);
  46. }
  47. }

runWorker函数循环从workQueue里获取 task并执行，但是需要注意以下几个问题：1.如果不想从workQueue里获取第一个任务执行，那就给worker.firstTask赋值。2、 如果getTask获取的值为null，或者你的task里抛异常了，那循环就退出了，然后worker线程也就退出了。3、在执行任务前先要获取 worker的锁，这里防止中断正在执行的线程。4、如果你的钩子函数beforeExecute函数抛异常了，那么你的任务就不会被执行 了，worker线程也会退出。5、如果task.run方法抛出Runtime或Error异常，会原样抛出，如果是Throwable，则会包装成一 个Error抛出，抛出异常前会执行afterExecute钩子函数，最后线程会退出。6、如果afterExecute钩子函数抛出异常，那么 worker线程也会退出。

[java] view plain copy

  1. private Runnable getTask() {
  2. boolean timedOut = false; // Did the last poll() time out?
  3. retry:
  4. for (;;) {
  5. int c = ctl.get();
  6. int rs = runStateOf(c);
  7. // 如果SHUTDOWN且workQueue为空，或者STOP了，worker线程直接退出
  8. if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
  9. decrementWorkerCount();
  10. return null;
  11. }
  12. // 是否要回收这个worker线程？
  13. boolean timed;      // Are workers subject to culling?
  14. for (;;) {
  15. int wc = workerCountOf(c);
  16. timed = allowCoreThreadTimeOut || wc > corePoolSize;
  17. // 如果还没有超时过(循环第一次执行到这里)直接break
  18. if (wc <= maximumPoolSize && ! (timedOut && timed))
  19. break;
  20. // 否则，如果线程数大于最大限制或者已经超时过了说明这个worker线程要准备退出了
  21. // 先设置workerCount-1，成功的话直接退出；否则，看下runState是否和rs一样，如
  22. // 果一样就在内部循环，不一样就要到外部循环
  23. if (compareAndDecrementWorkerCount(c))
  24. return null;
  25. c = ctl.get();  // Re-read ctl
  26. if (runStateOf(c) != rs)
  27. continue retry;
  28. // else CAS failed due to workerCount change; retry inner loop
  29. }
  30. try {
  31. // 无限阻塞或超时阻塞
  32. Runnable r = timed ?
  33. workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
  34. workQueue.take();
  35. if (r != null)
  36. return r;
  37. // 没有获取到task肯定是超时了
  38. timedOut = true;
  39. } catch (InterruptedException retry) {
  40. // 如果被中断了，不能算作超时
  41. timedOut = false;
  42. }
  43. }
  44. }

getTask函数是从workQueue里获取一个task，有两种策略（无限阻塞或者超时，具体要看客户端的配置）。如果这个函数返回了null，那么worker线程就会退出了。退出的原因不外乎以下几种：

1.   当前线程池中worker数量大于maximumPoolSize了；

2.   线程池被STOP了(workQueue.poll/take时会捕获到InterruptedException异常)；

3.   线程池被SHUTDOWN了且workQueue为空(workQueue.poll/take时会捕获到InterruptedException异常)；

4.   获取task超时了(timedOut)&&(timed)。

[java] view plain copy

  1. private void processWorkerExit(Worker w, boolean completedAbruptly) {
  2. // 用户的函数抛异常了，需要调整workerCount的值，因为worker线程准备退出了
  3. if (completedAbruptly) // If abrupt, then workerCount wasn‘t adjusted
  4. decrementWorkerCount();
  5. // 做些统计操作(bookkeeping)
  6. final ReentrantLock mainLock = this.mainLock;
  7. mainLock.lock();
  8. try {
  9. completedTaskCount += w.completedTasks;
  10. workers.remove(w);
  11. } finally {
  12. mainLock.unlock();
  13. }
  14. // 尝试终止线程池
  15. tryTerminate();
  16. int c = ctl.get();
  17. // 如果是RUNNING或SHUTDOWN状态，要看下workQueue是否为空,
  18. // 不能直接退出。如果workQueue不空，至少要保留1或corePoolSize个
  19. // 线程(看allowCoreThreadTimeOut配置)。少于这个数目，就需要通过
  20. // addWorker(null,false)方法补充新的线程进来。
  21. if (runStateLessThan(c, STOP)) {
  22. if (!completedAbruptly) {
  23. int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
  24. if (min == 0 && ! workQueue.isEmpty())
  25. min = 1;
  26. if (workerCountOf(c) >= min)
  27. return; // replacement not needed
  28. }
  29. addWorker(null, false);
  30. }
  31. }

processWorkerExit函数是在runWork 循环退出后做的清理和bookkeeping(应该就是指completedTaskCount等变量的操作吧)操作。 completedAbruptly参数的含义是指用户的函数是否抛异常了(before/after/run等)。注意下函数最后会根据线程池的状态和 配置决定是否新建一个worker线程。

原文地址：https://www.cnblogs.com/AndyAo/p/8135063.html

时间： 2024-11-06 07:15:34

Java 1.7 ThreadPoolExecutor源码解析的相关文章

Java集合---Array类源码解析

Java集合---Array类源码解析              ---转自:牛奶.不加糖 一.Arrays.sort()数组排序 Java Arrays中提供了对所有类型的排序.其中主要分为Primitive(8种基本类型)和Object两大类. 基本类型:采用调优的快速排序: 对象类型:采用改进的归并排序. 1.对于基本类型源码分析如下(以int[]为例): Java对Primitive(int,float等原型数据)数组采用快速排序,对Object对象数组采用归并排序.对这一区别,sun在

java.lang.Void类源码解析_java - JAVA

文章来源:嗨学网 敏而好学论坛www.piaodoo.com 欢迎大家相互学习 在一次源码查看ThreadGroup的时候,看到一段代码,为以下: /* * @throws NullPointerException if the parent argument is {@code null} * @throws SecurityException if the current thread cannot create a * thread in the specified thread grou

【Java并发编程】21、线程池ThreadPoolExecutor源码解析

一.前言 JUC这部分还有线程池这一块没有分析,需要抓紧时间分析,下面开始ThreadPoolExecutor,其是线程池的基础,分析完了这个类会简化之后的分析,线程池可以解决两个不同问题:由于减少了每个任务调用的开销,它们通常可以在执行大量异步任务时提供增强的性能,并且还可以提供绑定和管理资源(包括执行任务集时使用的线程)的方法.下面开始分析. 二.ThreadPoolExecutor数据结构 在ThreadPoolExecutor的内部,主要由BlockingQueue和AbstractQu

Java集合类库 ArrayList 源码解析

集合类库是Java的一个重大突破,方便了我们对大数据的操作.其中 Arrays 和 Collections 工具类可以帮助我们快速操作集合类库.下面对Java集合类库的源码分析是基于jdk1.7的.今天我们来看看ArrayList的底层实现原理. ArrayList的继承结构图 继承自 AbstractList 抽象类,在上层是 AbstractCollection 抽象类,直接去 AbstractCollection 类去看看. AbstractCollection 类主要实现了 Collec

【Java集合】-- LinkedList源码解析

目录 继承体系 数据结构 源码解析 1.属性 2.构造方法 LinkedList() LinkedList(Collection<? extends E> c) 3.添加元素 add(E e) addFirst(E e) addLast(E e) add(int index, E element) offer(E e) offerFirst(E e) offerLast(E e) 总结 4.获取元素 get(int index) getFirst() getLast() peek() 5.删除

Java集合类库 LinkedList 源码解析

基于JDK 1.7,和ArrayList进行比较分析 Java已经有了ArrayList,用来存放元素,对元素的操作都很方便.为什么还会有LinkedList呢?我们都知道ArrayList获取元素很快,但是插入一个元素很慢,因为ArrayList底层维护的是一个数组,往数组中的某个位置插入一个元素,是很消耗资源的. 而LinkedList插入元素很快,获取任意位置的元素却很慢.这是为什么呢?底层又是怎样实现的呢? 1.继承关系 LinkedList的继承关系图: LinkedList继承的是A

ThreadPoolExecutor源码解析

java doc中的解释是: An ExecutorService that executes each submitted task using one of possibly several pooled threads, normally configured using Executors factory methods. 一个使用线程池来执行提交的任务的ExecutorService子类,正常通过Executors工具类中的工厂方法进行配置. 那我们就先看一下比较熟悉的Executor

Java集合---Arrays类源码解析

一.Arrays.sort()数组排序 Java Arrays中提供了对所有类型的排序.其中主要分为Primitive(8种基本类型)和Object两大类. 基本类型:采用调优的快速排序: 对象类型:采用改进的归并排序. 1.对于基本类型源码分析如下(以int[]为例): Java对Primitive(int,float等原型数据)数组采用快速排序,对Object对象数组采用归并排序.对这一区别,sun在<<The Java Tutorial>>中做出的解释如下: The sort

Java 1.8 ArrayList源码解析

1 // 非线程安全 2 // 继承了AbstractList类 3 // 实现了List.RandomAccess.Cloneable.java.io.Serializable接口 4 // 后面3个接口是标记接口,没有抽象方法. 5 // 表示ArrayList可以随机访问.浅复制.序列化和反序列化. 6 public class ArrayList<E> extends AbstractList<E> 7 implements List<E>, RandomAcc